Pārlūkot izejas kodu

add peg-markdown-highlight for markdown editing highlight

[peg-markdown-highlight](https://github.com/ali-rantakari/peg-markdown-highlight.git)

Signed-off-by: Le Tan <[email protected]>
Le Tan 9 gadi atpakaļ
vecāks
revīzija
22bf96c6e3

+ 7 - 2
VNote.pro

@@ -27,7 +27,9 @@ SOURCES += main.cpp\
     vnotefile.cpp \
     vdocument.cpp \
     utils/vutils.cpp \
-    vpreviewpage.cpp
+    vpreviewpage.cpp \
+    utils/peg-highlight/pmh_parser.c \
+    hgmarkdownhighlighter.cpp
 
 HEADERS  += vmainwindow.h \
     vdirectorytree.h \
@@ -44,7 +46,10 @@ HEADERS  += vmainwindow.h \
     vnotefile.h \
     vdocument.h \
     utils/vutils.h \
-    vpreviewpage.h
+    vpreviewpage.h \
+    utils/peg-highlight/pmh_parser.h \
+    hgmarkdownhighlighter.h \
+    utils/peg-highlight/pmh_definitions.h
 
 RESOURCES += \
     vnote.qrc

+ 229 - 0
hgmarkdownhighlighter.cpp

@@ -0,0 +1,229 @@
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * highlighter.cpp
+ * 
+ * Qt 4.7 example for highlighting a rich text widget.
+ */
+
+#include <QtGui>
+#include "hgmarkdownhighlighter.h"
+
+WorkerThread::~WorkerThread()
+{
+    if (result != NULL)
+        pmh_free_elements(result);
+    free(content);
+}
+void WorkerThread::run()
+{
+    if (content == NULL)
+        return;
+    pmh_markdown_to_elements(content, pmh_EXT_NONE, &result);
+}
+
+HGMarkdownHighlighter::HGMarkdownHighlighter(QTextDocument *parent,
+                                             int aWaitInterval) : QObject(parent)
+{
+    highlightingStyles = NULL;
+    workerThread = NULL;
+    cached_elements = NULL;
+    waitInterval = aWaitInterval;
+    timer = new QTimer(this);
+    timer->setSingleShot(true);
+    timer->setInterval(aWaitInterval);
+    connect(timer, SIGNAL(timeout()), this, SLOT(timerTimeout()));
+    document = parent;
+    connect(document, SIGNAL(contentsChange(int,int,int)),
+            this, SLOT(handleContentsChange(int,int,int)));
+
+    this->parse();
+}
+
+void HGMarkdownHighlighter::setStyles(QVector<HighlightingStyle> &styles)
+{
+    this->highlightingStyles = &styles;
+}
+
+#define STY(type, format) styles->append((HighlightingStyle){type, format})
+
+void HGMarkdownHighlighter::setDefaultStyles()
+{
+    QVector<HighlightingStyle> *styles = new QVector<HighlightingStyle>();
+
+    QTextCharFormat headers; headers.setForeground(QBrush(Qt::darkBlue));
+    headers.setBackground(QBrush(QColor(230,230,240)));
+    STY(pmh_H1, headers);
+    STY(pmh_H2, headers);
+    STY(pmh_H3, headers);
+    STY(pmh_H4, headers);
+    STY(pmh_H5, headers);
+    STY(pmh_H6, headers);
+
+    QTextCharFormat hrule; hrule.setForeground(QBrush(Qt::darkGray));
+    hrule.setBackground(QBrush(Qt::lightGray));
+    STY(pmh_HRULE, hrule);
+
+    QTextCharFormat list; list.setForeground(QBrush(Qt::magenta));
+    STY(pmh_LIST_BULLET, list);
+    STY(pmh_LIST_ENUMERATOR, list);
+
+    QTextCharFormat link; link.setForeground(QBrush(Qt::darkCyan));
+    link.setBackground(QBrush(QColor(205,240,240)));
+    STY(pmh_LINK, link);
+    STY(pmh_AUTO_LINK_URL, link);
+    STY(pmh_AUTO_LINK_EMAIL, link);
+
+    QTextCharFormat image; image.setForeground(QBrush(Qt::darkCyan));
+    image.setBackground(QBrush(Qt::cyan));
+    STY(pmh_IMAGE, image);
+
+    QTextCharFormat ref; ref.setForeground(QBrush(QColor(213,178,178)));
+    STY(pmh_REFERENCE, ref);
+
+    QTextCharFormat code; code.setForeground(QBrush(Qt::darkGreen));
+    code.setBackground(QBrush(QColor(217,231,217)));
+    STY(pmh_CODE, code);
+    STY(pmh_VERBATIM, code);
+
+    QTextCharFormat emph; emph.setForeground(QBrush(Qt::darkYellow));
+    emph.setFontItalic(true);
+    STY(pmh_EMPH, emph);
+
+    QTextCharFormat strong; strong.setForeground(QBrush(Qt::magenta));
+    strong.setFontWeight(QFont::Bold);
+    STY(pmh_STRONG, strong);
+
+    QTextCharFormat comment; comment.setForeground(QBrush(Qt::gray));
+    STY(pmh_COMMENT, comment);
+
+    QTextCharFormat blockquote; blockquote.setForeground(QBrush(Qt::darkRed));
+    STY(pmh_BLOCKQUOTE, blockquote);
+
+    this->setStyles(*styles);
+}
+
+void HGMarkdownHighlighter::clearFormatting()
+{
+    QTextBlock block = document->firstBlock();
+    while (block.isValid()) {
+        block.layout()->clearAdditionalFormats();
+        block = block.next();
+    }
+}
+
+void HGMarkdownHighlighter::highlight()
+{
+    if (cached_elements == NULL) {
+        qDebug() << "cached_elements is NULL";
+        return;
+    }
+
+    if (highlightingStyles == NULL)
+        this->setDefaultStyles();
+
+    this->clearFormatting();
+
+    for (int i = 0; i < highlightingStyles->size(); i++)
+    {
+        HighlightingStyle style = highlightingStyles->at(i);
+        pmh_element *elem_cursor = cached_elements[style.type];
+        while (elem_cursor != NULL)
+        {
+            if (elem_cursor->end <= elem_cursor->pos) {
+                elem_cursor = elem_cursor->next;
+                continue;
+            }
+
+            // "The QTextLayout object can only be modified from the
+            // documentChanged implementation of a QAbstractTextDocumentLayout
+            // subclass. Any changes applied from the outside cause undefined
+            // behavior." -- we are breaking this rule here. There might be
+            // a better (more correct) way to do this.
+
+            int startBlockNum = document->findBlock(elem_cursor->pos).blockNumber();
+            int endBlockNum = document->findBlock(elem_cursor->end).blockNumber();
+            for (int j = startBlockNum; j <= endBlockNum; j++)
+            {
+                QTextBlock block = document->findBlockByNumber(j);
+
+                QTextLayout *layout = block.layout();
+                QList<QTextLayout::FormatRange> list = layout->additionalFormats();
+                int blockpos = block.position();
+                QTextLayout::FormatRange r;
+                r.format = style.format;
+
+                if (j == startBlockNum) {
+                    r.start = elem_cursor->pos - blockpos;
+                    r.length = (startBlockNum == endBlockNum)
+                                ? elem_cursor->end - elem_cursor->pos
+                                : block.length() - r.start;
+                } else if (j == endBlockNum) {
+                    r.start = 0;
+                    r.length = elem_cursor->end - blockpos;
+                } else {
+                    r.start = 0;
+                    r.length = block.length();
+                }
+
+                list.append(r);
+                layout->setAdditionalFormats(list);
+            }
+
+            elem_cursor = elem_cursor->next;
+        }
+    }
+
+    document->markContentsDirty(0, document->characterCount());
+}
+
+void HGMarkdownHighlighter::parse()
+{
+    if (workerThread != NULL && workerThread->isRunning()) {
+        parsePending = true;
+        return;
+    }
+
+    QString content = document->toPlainText();
+    QByteArray ba = content.toUtf8();
+    char *content_cstring = strdup((char *)ba.data());
+
+    if (workerThread != NULL)
+        delete workerThread;
+    workerThread = new WorkerThread();
+    workerThread->content = content_cstring;
+    connect(workerThread, SIGNAL(finished()), this, SLOT(threadFinished()));
+    parsePending = false;
+    workerThread->start();
+}
+
+void HGMarkdownHighlighter::threadFinished()
+{
+    if (parsePending) {
+        this->parse();
+        return;
+    }
+
+    if (cached_elements != NULL)
+        pmh_free_elements(cached_elements);
+    cached_elements = workerThread->result;
+    workerThread->result = NULL;
+
+    this->highlight();
+}
+
+void HGMarkdownHighlighter::handleContentsChange(int position, int charsRemoved,
+                                                 int charsAdded)
+{
+    if (charsRemoved == 0 && charsAdded == 0)
+        return;
+
+    timer->stop();
+    timer->start();
+}
+
+void HGMarkdownHighlighter::timerTimeout()
+{
+    this->parse();
+}

+ 67 - 0
hgmarkdownhighlighter.h

@@ -0,0 +1,67 @@
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * highlighter.h
+ * 
+ * Qt 4.7 example for highlighting a rich text widget.
+ */
+
+#ifndef HGMARKDOWNHIGHLIGHTER_H
+#define HGMARKDOWNHIGHLIGHTER_H
+
+#include <QTextCharFormat>
+#include <QThread>
+
+extern "C" {
+#include "utils/peg-highlight/pmh_parser.h"
+}
+
+QT_BEGIN_NAMESPACE
+class QTextDocument;
+QT_END_NAMESPACE
+
+class WorkerThread : public QThread
+{
+public:
+    ~WorkerThread();
+    void run();
+    char *content;
+    pmh_element **result;
+};
+
+struct HighlightingStyle
+{
+    pmh_element_type type;
+    QTextCharFormat format;
+};
+
+class HGMarkdownHighlighter : public QObject
+{
+    Q_OBJECT
+
+public:
+    HGMarkdownHighlighter(QTextDocument *parent = 0, int aWaitInterval = 2000);
+    void setStyles(QVector<HighlightingStyle> &styles);
+    int waitInterval;
+
+private slots:
+    void handleContentsChange(int position, int charsRemoved, int charsAdded);
+    void threadFinished();
+    void timerTimeout();
+
+private:
+    QTimer *timer;
+    QTextDocument *document;
+    WorkerThread *workerThread;
+    bool parsePending;
+    pmh_element **cached_elements;
+    QVector<HighlightingStyle> *highlightingStyles;
+
+    void clearFormatting();
+    void highlight();
+    void parse();
+    void setDefaultStyles();
+};
+
+#endif

+ 125 - 0
utils/peg-highlight/pmh_definitions.h

@@ -0,0 +1,125 @@
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * pmh_definitions.h
+ */
+
+#ifndef pmh_MARKDOWN_DEFINITIONS
+#define pmh_MARKDOWN_DEFINITIONS
+
+/** \file
+* \brief Global definitions for the parser.
+*/
+
+
+/**
+* \brief Element types.
+* 
+* The first (documented) ones are language element types.
+* 
+* The last (non-documented) ones are utility types used
+* by the parser itself.
+* 
+* \sa pmh_element
+*/
+typedef enum
+{
+    pmh_LINK,               /**< Explicit link */
+    pmh_AUTO_LINK_URL,      /**< Implicit URL link */
+    pmh_AUTO_LINK_EMAIL,    /**< Implicit email link */
+    pmh_IMAGE,              /**< Image definition */
+    pmh_CODE,               /**< Code (inline) */
+    pmh_HTML,               /**< HTML */
+    pmh_HTML_ENTITY,        /**< HTML special entity definition */
+    pmh_EMPH,               /**< Emphasized text */
+    pmh_STRONG,             /**< Strong text */
+    pmh_LIST_BULLET,        /**< Bullet for an unordered list item */
+    pmh_LIST_ENUMERATOR,    /**< Enumerator for an ordered list item */
+    pmh_COMMENT,            /**< (HTML) Comment */
+    
+    // Code assumes that pmh_H1-6 are in order.
+    pmh_H1,                 /**< Header, level 1 */
+    pmh_H2,                 /**< Header, level 2 */
+    pmh_H3,                 /**< Header, level 3 */
+    pmh_H4,                 /**< Header, level 4 */
+    pmh_H5,                 /**< Header, level 5 */
+    pmh_H6,                 /**< Header, level 6 */
+    
+    pmh_BLOCKQUOTE,         /**< Blockquote */
+    pmh_VERBATIM,           /**< Verbatim (e.g. block of code) */
+    pmh_HTMLBLOCK,          /**< Block of HTML */
+    pmh_HRULE,              /**< Horizontal rule */
+    pmh_REFERENCE,          /**< Reference */
+    pmh_NOTE,               /**< Note */
+    pmh_STRIKE,             /**< Strike-through */
+    
+    // Utility types used by the parser itself:
+    
+    // List of pmh_RAW element lists, each to be processed separately from
+    // others (for each element in linked lists of this type, `children` points
+    // to a linked list of pmh_RAW elements):
+    pmh_RAW_LIST,   /**< Internal to parser. Please ignore. */
+    
+    // Span marker for positions in original input to be post-processed
+    // in a second parsing step:
+    pmh_RAW,        /**< Internal to parser. Please ignore. */
+    
+    // Additional text to be parsed along with spans in the original input
+    // (these may be added to linked lists of pmh_RAW elements):
+    pmh_EXTRA_TEXT, /**< Internal to parser. Please ignore. */
+    
+    // Separates linked lists of pmh_RAW elements into parts to be processed
+    // separate from each other:
+    pmh_SEPARATOR,  /**< Internal to parser. Please ignore. */
+    
+    // Placeholder element used while parsing:
+    pmh_NO_TYPE,    /**< Internal to parser. Please ignore. */
+    
+    // Linked list of *all* elements created while parsing:
+    pmh_ALL         /**< Internal to parser. Please ignore. */
+} pmh_element_type;
+
+/**
+* \brief Number of types in pmh_element_type.
+* \sa pmh_element_type
+*/
+#define pmh_NUM_TYPES 31
+
+/**
+* \brief Number of *language element* types in pmh_element_type.
+* \sa pmh_element_type
+*/
+#define pmh_NUM_LANG_TYPES (pmh_NUM_TYPES - 6)
+
+
+/**
+* \brief A Language element occurrence.
+*/
+struct pmh_Element
+{
+    pmh_element_type type;    /**< \brief Type of element */
+    unsigned long pos;        /**< \brief Unicode code point offset marking the
+                                          beginning of this element in the
+                                          input. */
+    unsigned long end;        /**< \brief Unicode code point offset marking the
+                                          end of this element in the input. */
+    struct pmh_Element *next; /**< \brief Next element in list */
+    char *label;              /**< \brief Label (for links and references) */
+    char *address;            /**< \brief Address (for links and references) */
+};
+typedef struct pmh_Element pmh_element;
+
+/**
+* \brief Bitfield enumeration of supported Markdown extensions.
+*/
+enum pmh_extensions
+{
+    pmh_EXT_NONE    = 0,        /**< No extensions */
+    pmh_EXT_NOTES   = (1 << 0), /**< Footnote syntax:
+                                     http://pandoc.org/README.html#footnotes */
+    pmh_EXT_STRIKE  = (1 << 1)  /**< Strike-through syntax:
+                                     http://pandoc.org/README.html#strikeout */
+};
+
+#endif

+ 6550 - 0
utils/peg-highlight/pmh_parser.c

@@ -0,0 +1,6550 @@
+/* A recursive-descent parser generated by greg 0.4.3 */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+struct _GREG;
+#define YYRULECOUNT 225
+
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * pmh_grammar.leg
+ * 
+ * This is a slightly adapted version of the PEG grammar from John MacFarlane's
+ * peg-markdown compiler.
+ */
+
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * pmh_parser_head.c
+ * 
+ * Code to be inserted into the beginning of the parser code generated
+ * from the PEG grammar.
+ */
+
+#include "pmh_parser.h"
+
+#ifndef pmh_DEBUG_OUTPUT
+#define pmh_DEBUG_OUTPUT 0
+#endif
+
+#if pmh_DEBUG_OUTPUT
+#define pmh_IF(x)           if (x)
+#define pmh_PRINTF(x, ...)  fprintf(stderr, x, ##__VA_ARGS__)
+#define pmh_PUTCHAR(x)      putchar(x)
+#else
+#define pmh_IF(x)
+#define pmh_PRINTF(x, ...)
+#define pmh_PUTCHAR(x)
+#endif
+
+
+
+// Alias strdup to _strdup on MSVC:
+#ifdef _MSC_VER
+#define strdup _strdup
+#endif
+
+
+char *strdup_or_null(char *s)
+{
+    return (s == NULL) ? NULL : strdup(s);
+}
+
+
+// Internal language element occurrence structure, containing
+// both public and private members:
+struct pmh_RealElement
+{
+    // "Public" members:
+    // (these must match what's defined in pmh_definitions.h)
+    // -----------------------------------------------
+    pmh_element_type type;
+    unsigned long pos;
+    unsigned long end;
+    struct pmh_RealElement *next;
+    char *label;
+    char *address;
+    
+    // "Private" members for use by the parser itself:
+    // -----------------------------------------------
+    
+    // next element in list of all elements:
+    struct pmh_RealElement *all_elems_next;
+    
+    // offset to text (for elements of type pmh_EXTRA_TEXT, used when the
+    // parser reads the value of 'text'):
+    int text_offset;
+    
+    // text content (for elements of type pmh_EXTRA_TEXT):
+    char *text;
+    
+    // children of element (for elements of type pmh_RAW_LIST)
+    struct pmh_RealElement *children;
+};
+typedef struct pmh_RealElement pmh_realelement;
+
+
+
+
+// Parser state data:
+typedef struct
+{
+    /* The original, unmodified UTF-8 input: */
+    char *original_input;
+    
+    /* The offsets of the bytes we have stripped from original_input: */
+    unsigned long *strip_positions;
+    size_t strip_positions_len;
+    
+    /* Buffer of characters to be parsed: */
+    char *charbuf;
+    
+    /* Linked list of {start, end} offset pairs determining which parts */
+    /* of charbuf to actually parse: */
+    pmh_realelement *current_elem;
+    pmh_realelement *elem_head;
+    
+    /* Current parsing offset within charbuf: */
+    unsigned long offset;
+    
+    /* The extensions to use for parsing (bitfield */
+    /* of enum pmh_extensions): */
+    int extensions;
+    
+    /* Array of parsing result elements, indexed by type: */
+    pmh_realelement **head_elems;
+    
+    /* Whether we are parsing only references: */
+    bool parsing_only_references;
+    
+    /* List of reference elements: */
+    pmh_realelement *references;
+} parser_data;
+
+static parser_data *mk_parser_data(char *original_input,
+                                   unsigned long *strip_positions,
+                                   size_t strip_positions_len,
+                                   char *charbuf,
+                                   pmh_realelement *parsing_elems,
+                                   unsigned long offset,
+                                   int extensions,
+                                   pmh_realelement **head_elems,
+                                   pmh_realelement *references)
+{
+    parser_data *p_data = (parser_data *)malloc(sizeof(parser_data));
+    p_data->extensions = extensions;
+    p_data->original_input = original_input;
+    p_data->strip_positions = strip_positions;
+    p_data->strip_positions_len = strip_positions_len;
+    p_data->charbuf = charbuf;
+    p_data->offset = offset;
+    p_data->elem_head = p_data->current_elem = parsing_elems;
+    p_data->references = references;
+    p_data->parsing_only_references = false;
+    if (head_elems != NULL)
+        p_data->head_elems = head_elems;
+    else {
+        p_data->head_elems = (pmh_realelement **)
+                             malloc(sizeof(pmh_realelement *) * pmh_NUM_TYPES);
+        int i;
+        for (i = 0; i < pmh_NUM_TYPES; i++)
+            p_data->head_elems[i] = NULL;
+    }
+    return p_data;
+}
+
+
+// Forward declarations
+static void parse_markdown(parser_data *p_data);
+static void parse_references(parser_data *p_data);
+
+
+
+
+
+static char **get_element_type_names()
+{
+    static char **elem_type_names = NULL;
+    if (elem_type_names == NULL)
+    {
+        elem_type_names = (char **)malloc(sizeof(char*) * pmh_NUM_LANG_TYPES);
+        int i;
+        for (i = 0; i < pmh_NUM_LANG_TYPES; i++)
+            elem_type_names[i] = NULL;
+        elem_type_names[pmh_LINK] = "LINK";
+        elem_type_names[pmh_AUTO_LINK_URL] = "AUTO_LINK_URL";
+        elem_type_names[pmh_AUTO_LINK_EMAIL] = "AUTO_LINK_EMAIL";
+        elem_type_names[pmh_IMAGE] = "IMAGE";
+        elem_type_names[pmh_CODE] = "CODE";
+        elem_type_names[pmh_HTML] = "HTML";
+        elem_type_names[pmh_HTML_ENTITY] = "HTML_ENTITY";
+        elem_type_names[pmh_EMPH] = "EMPH";
+        elem_type_names[pmh_STRONG] = "STRONG";
+        elem_type_names[pmh_LIST_BULLET] = "LIST_BULLET";
+        elem_type_names[pmh_LIST_ENUMERATOR] = "LIST_ENUMERATOR";
+        elem_type_names[pmh_COMMENT] = "COMMENT";
+        elem_type_names[pmh_H1] = "H1";
+        elem_type_names[pmh_H2] = "H2";
+        elem_type_names[pmh_H3] = "H3";
+        elem_type_names[pmh_H4] = "H4";
+        elem_type_names[pmh_H5] = "H5";
+        elem_type_names[pmh_H6] = "H6";
+        elem_type_names[pmh_BLOCKQUOTE] = "BLOCKQUOTE";
+        elem_type_names[pmh_VERBATIM] = "VERBATIM";
+        elem_type_names[pmh_HTMLBLOCK] = "HTMLBLOCK";
+        elem_type_names[pmh_HRULE] = "HRULE";
+        elem_type_names[pmh_REFERENCE] = "REFERENCE";
+        elem_type_names[pmh_NOTE] = "NOTE";
+        elem_type_names[pmh_STRIKE] = "STRIKE";
+    }
+    return elem_type_names;
+}
+
+pmh_element_type pmh_element_type_from_name(char *name)
+{
+    char **elem_type_names = get_element_type_names();
+    
+    int i;
+    for (i = 0; i < pmh_NUM_LANG_TYPES; i++)
+    {
+        char *i_name = elem_type_names[i];
+        if (i_name == NULL)
+            continue;
+        if (strcmp(i_name, name) == 0)
+            return i;
+    }
+    
+    return pmh_NO_TYPE;
+}
+
+char *pmh_element_name_from_type(pmh_element_type type)
+{
+    char **elem_type_names = get_element_type_names();
+    char* ret = elem_type_names[type];
+    if (ret == NULL)
+        return "unknown type";
+    return ret;
+}
+
+
+
+
+/*
+Remove pmh_RAW elements with zero length; return pointer
+to new head.
+*/
+static pmh_realelement *remove_zero_length_raw_spans(pmh_realelement *elem)
+{
+    pmh_realelement *head = elem;
+    pmh_realelement *parent = NULL;
+    pmh_realelement *c = head;
+    while (c != NULL)
+    {
+        if (c->type == pmh_RAW && c->pos >= c->end)
+        {
+            if (parent != NULL)
+                parent->next = c->next;
+            else
+                head = c->next;
+            parent = c;
+            c = c->next;
+            continue;
+        }
+        parent = c;
+        c = c->next;
+    }
+    return head;
+}
+
+#if pmh_DEBUG_OUTPUT
+/*
+Print null-terminated string s.t. some characters are
+represented by their corresponding espace sequences
+*/
+static void print_str_literal_escapes(char *str)
+{
+    char *c = str;
+    pmh_PRINTF("'");
+    while (*c != '\0')
+    {
+        if (*c == '\n')         pmh_PRINTF("\\n");
+        else if (*c == '\t')    pmh_PRINTF("\\t");
+        else putchar(*c);
+        c++;
+    }
+    pmh_PRINTF("'");
+}
+#endif
+
+#if pmh_DEBUG_OUTPUT
+/*
+Print elements in a linked list of
+pmh_RAW, pmh_SEPARATOR, pmh_EXTRA_TEXT elements
+*/
+static void print_raw_spans_inline(pmh_realelement *elem)
+{
+    pmh_realelement *cur = elem;
+    while (cur != NULL)
+    {
+        if (cur->type == pmh_SEPARATOR)
+            pmh_PRINTF("<pmh_SEP %ld> ", cur->pos);
+        else if (cur->type == pmh_EXTRA_TEXT) {
+            pmh_PRINTF("{pmh_ETEXT ");
+            print_str_literal_escapes(cur->text);
+            pmh_PRINTF("}");
+        }
+        else
+            pmh_PRINTF("(%ld-%ld) ", cur->pos, cur->end);
+        cur = cur->next;
+    }
+}
+#endif
+
+/*
+Perform postprocessing parsing runs for pmh_RAW_LIST elements in `elem`,
+iteratively until no such elements exist.
+*/
+static void process_raw_blocks(parser_data *p_data)
+{
+    pmh_PRINTF("--------process_raw_blocks---------\n");
+    while (p_data->head_elems[pmh_RAW_LIST] != NULL)
+    {
+        pmh_PRINTF("new iteration.\n");
+        pmh_realelement *cursor = p_data->head_elems[pmh_RAW_LIST];
+        p_data->head_elems[pmh_RAW_LIST] = NULL;
+        while (cursor != NULL)
+        {
+            pmh_realelement *span_list = (pmh_realelement*)cursor->children;
+            
+            span_list = remove_zero_length_raw_spans(span_list);
+            
+            #if pmh_DEBUG_OUTPUT
+            pmh_PRINTF("  process: ");
+            print_raw_spans_inline(span_list);
+            pmh_PRINTF("\n");
+            #endif
+            
+            while (span_list != NULL)
+            {
+                pmh_PRINTF("next: span_list: %ld-%ld\n",
+                           span_list->pos, span_list->end);
+                
+                // Skip separators in the beginning, as well as
+                // separators after another separator:
+                if (span_list->type == pmh_SEPARATOR) {
+                    span_list = span_list->next;
+                    continue;
+                }
+                
+                // Store list of spans until next separator in subspan_list:
+                pmh_realelement *subspan_list = span_list;
+                pmh_realelement *previous = NULL;
+                while (span_list != NULL && span_list->type != pmh_SEPARATOR) {
+                    previous = span_list;
+                    span_list = span_list->next;
+                }
+                if (span_list != NULL && span_list->type == pmh_SEPARATOR) {
+                    span_list = span_list->next;
+                    previous->next = NULL;
+                }
+                
+                #if pmh_DEBUG_OUTPUT
+                pmh_PRINTF("    subspan process: ");
+                print_raw_spans_inline(subspan_list);
+                pmh_PRINTF("\n");
+                #endif
+                
+                // Process subspan_list:
+                parser_data *raw_p_data = mk_parser_data(
+                    p_data->original_input,
+                    p_data->strip_positions,
+                    p_data->strip_positions_len,
+                    p_data->charbuf,
+                    subspan_list,
+                    subspan_list->pos,
+                    p_data->extensions,
+                    p_data->head_elems,
+                    p_data->references
+                );
+                parse_markdown(raw_p_data);
+                free(raw_p_data);
+                
+                pmh_PRINTF("parse over\n");
+            }
+            
+            cursor = cursor->next;
+        }
+    }
+}
+
+
+#if pmh_DEBUG_OUTPUT
+static void print_raw_blocks(char *text, pmh_realelement *elem[])
+{
+    pmh_PRINTF("--------print_raw_blocks---------\n");
+    pmh_PRINTF("block:\n");
+    pmh_realelement *cursor = elem[pmh_RAW_LIST];
+    while (cursor != NULL)
+    {
+        print_raw_spans_inline(cursor->children);
+        cursor = cursor->next;
+    }
+}
+#endif
+
+
+
+
+/* Free all elements created while parsing */
+void pmh_free_elements(pmh_element **elems)
+{
+    pmh_realelement *cursor = (pmh_realelement*)elems[pmh_ALL];
+    while (cursor != NULL) {
+        pmh_realelement *tofree = cursor;
+        cursor = cursor->all_elems_next;
+        if (tofree->text != NULL)
+            free(tofree->text);
+        if (tofree->label != NULL)
+            free(tofree->label);
+        if (tofree->address != NULL)
+            free(tofree->address);
+        free(tofree);
+    }
+    elems[pmh_ALL] = NULL;
+    
+    free(elems);
+}
+
+
+
+
+
+
+#define IS_CONTINUATION_BYTE(x) ((x & 0xC0) == 0x80)
+#define HAS_UTF8_BOM(x)         ( ((*x & 0xFF) == 0xEF)\
+                                  && ((*(x+1) & 0xFF) == 0xBB)\
+                                  && ((*(x+2) & 0xFF) == 0xBF) )
+#define ADD_STRIP_POS(x) \
+    /* reallocate more space for the array, if needed: */ \
+    if (strip_positions_size <= strip_positions_pos) { \
+        size_t new_size = strip_positions_size * 2; \
+        unsigned long *new_arr = (unsigned long *) \
+                                 calloc(new_size, \
+                                        sizeof(unsigned long)); \
+        memcpy(new_arr, strip_positions, \
+               (sizeof(unsigned long) * strip_positions_size)); \
+        strip_positions_size = new_size; \
+        free(strip_positions); \
+        strip_positions = new_arr; \
+    } \
+    strip_positions[strip_positions_pos] = x; \
+    strip_positions_pos++;
+
+/*
+Copy `str` to `out`, while doing the following:
+  - remove UTF-8 continuation bytes
+  - remove possible UTF-8 BOM (byte order mark)
+  - append two newlines to the end (like peg-markdown does)
+  - keep track of which bytes we have stripped (in strip_positions)
+*/
+static int strcpy_preformat(char *str, char **out,
+                            unsigned long **out_strip_positions,
+                            size_t *out_strip_positions_len)
+{
+    size_t strip_positions_size = 1024;
+    size_t strip_positions_pos = 0;
+    unsigned long *strip_positions = (unsigned long *)
+                                     calloc(strip_positions_size,
+                                            sizeof(unsigned long));
+    
+    
+    // +2 in the following is due to the "\n\n" suffix:
+    char *new_str = (char *)malloc(sizeof(char) * strlen(str) + 1 + 2);
+    char *c = str;
+    int i = 0;
+    
+    if (HAS_UTF8_BOM(c)) {
+        c += 3;
+        ADD_STRIP_POS(0);
+        ADD_STRIP_POS(1);
+        ADD_STRIP_POS(2);
+    }
+    
+    while (*c != '\0')
+    {
+        if (!IS_CONTINUATION_BYTE(*c)) {
+            *(new_str+i) = *c, i++;
+        } else {
+            ADD_STRIP_POS((int)(c-str));
+        }
+        c++;
+    }
+    
+    *(new_str+(i++)) = '\n';
+    *(new_str+(i++)) = '\n';
+    *(new_str+i) = '\0';
+    
+    *out = new_str;
+    *out_strip_positions = strip_positions;
+    *out_strip_positions_len = strip_positions_pos;
+    return i;
+}
+
+
+
+void pmh_markdown_to_elements(char *text, int extensions,
+                              pmh_element **out_result[])
+{
+    char *text_copy = NULL;
+    unsigned long *strip_positions = NULL;
+    size_t strip_positions_len = 0;
+    int text_copy_len = strcpy_preformat(text, &text_copy, &strip_positions,
+                                         &strip_positions_len);
+    
+    pmh_realelement *parsing_elem = (pmh_realelement *)
+                                    malloc(sizeof(pmh_realelement));
+    parsing_elem->type = pmh_RAW;
+    parsing_elem->pos = 0;
+    parsing_elem->end = text_copy_len;
+    parsing_elem->next = NULL;
+    
+    parser_data *p_data = mk_parser_data(
+        text,
+        strip_positions,
+        strip_positions_len,
+        text_copy,
+        parsing_elem,
+        0,
+        extensions,
+        NULL,
+        NULL
+    );
+    pmh_realelement **result = p_data->head_elems;
+    
+    if (*text_copy != '\0')
+    {
+        // Get reference definitions into p_data->references
+        parse_references(p_data);
+        
+        // Reset parser state to beginning of input
+        p_data->offset = 0;
+        p_data->current_elem = p_data->elem_head;
+        
+        // Parse whole document
+        parse_markdown(p_data);
+        
+        #if pmh_DEBUG_OUTPUT
+        print_raw_blocks(text_copy, result);
+        #endif
+        
+        process_raw_blocks(p_data);
+    }
+    
+    free(strip_positions);
+    free(p_data);
+    free(parsing_elem);
+    free(text_copy);
+    
+    *out_result = (pmh_element**)result;
+}
+
+
+
+/*
+Mergesort linked list of elements (using comparison function `compare`),
+return new head. (Adapted slightly from Simon Tatham's algorithm.)
+*/
+static pmh_element *ll_mergesort(pmh_element *list,
+                                 int (*compare)(const pmh_element*,
+                                                const pmh_element*))
+{
+    if (!list)
+        return NULL;
+    
+    pmh_element *out_head = list;
+    
+    /* Merge widths of doubling size until done */
+    int merge_width = 1;
+    while (1)
+    {
+        pmh_element *l, *r; /* left & right segment pointers */
+        pmh_element *tail = NULL; /* tail of sorted section */
+        
+        l = out_head;
+        out_head = NULL;
+        
+        int merge_count = 0;
+        
+        while (l)
+        {
+            merge_count++;
+            
+            /* Position r, determine lsize & rsize */
+            r = l;
+            int lsize = 0;
+            int i;
+            for (i = 0; i < merge_width; i++) {
+                lsize++;
+                r = r->next;
+                if (!r)
+                    break;
+            }
+            int rsize = merge_width;
+            
+            /* Merge l & r */
+            while (lsize > 0 || (rsize > 0 && r))
+            {
+                bool get_from_left = false;
+                if (lsize == 0)             get_from_left = false;
+                else if (rsize == 0 || !r)  get_from_left = true;
+                else if (compare(l,r) <= 0) get_from_left = true;
+                
+                pmh_element *e;
+                if (get_from_left) {
+                    e = l; l = l->next; lsize--;
+                } else {
+                    e = r; r = r->next; rsize--;
+                }
+                
+                /* add the next pmh_element to the merged list */
+                if (tail)
+                    tail->next = e;
+                else
+                    out_head = e;
+                tail = e;
+            }
+            
+            l = r;
+        }
+        tail->next = NULL;
+        
+        if (merge_count <= 1)
+            return out_head;
+        
+        merge_width *= 2;
+    }
+}
+
+static int elem_compare_by_pos(const pmh_element *a, const pmh_element *b)
+{
+    return a->pos - b->pos;
+}
+
+void pmh_sort_elements_by_pos(pmh_element *element_lists[])
+{
+    int i;
+    for (i = 0; i < pmh_NUM_LANG_TYPES; i++)
+        element_lists[i] = ll_mergesort(element_lists[i], &elem_compare_by_pos);
+}
+
+
+
+
+
+
+
+
+/* return true if extension is selected */
+static bool extension(parser_data *p_data, int ext)
+{
+    return ((p_data->extensions & ext) != 0);
+}
+
+/* return reference pmh_realelement for a given label */
+static pmh_realelement *get_reference(parser_data *p_data, char *label)
+{
+    if (!label)
+        return NULL;
+    
+    pmh_realelement *cursor = p_data->references;
+    while (cursor != NULL)
+    {
+        if (cursor->label && strcmp(label, cursor->label) == 0)
+            return cursor;
+        cursor = cursor->next;
+    }
+    return NULL;
+}
+
+
+/* cons an element/list onto a list, returning pointer to new head */
+static pmh_realelement *cons(pmh_realelement *elem, pmh_realelement *list)
+{
+    assert(elem != NULL);
+    
+    pmh_realelement *cur = elem;
+    while (cur->next != NULL) {
+        cur = cur->next;
+    }
+    cur->next = list;
+    
+    return elem;
+}
+
+
+/* reverse a list, returning pointer to new list */
+static pmh_realelement *reverse(pmh_realelement *list)
+{
+    pmh_realelement *new_head = NULL;
+    pmh_realelement *next = NULL;
+    while (list != NULL) {
+        next = list->next;
+        list->next = new_head;
+        new_head = list;
+        list = next;
+    }
+    return new_head;
+}
+
+
+
+/* construct pmh_realelement */
+static pmh_realelement *mk_element(parser_data *p_data, pmh_element_type type,
+                                   long pos, long end)
+{
+    pmh_realelement *result = (pmh_realelement *)malloc(sizeof(pmh_realelement));
+    memset(result, 0, sizeof(*result));
+    result->type = type;
+    result->pos = pos;
+    result->end = end;
+    
+    pmh_realelement *old_all_elements_head = p_data->head_elems[pmh_ALL];
+    p_data->head_elems[pmh_ALL] = result;
+    result->all_elems_next = old_all_elements_head;
+    
+    //pmh_PRINTF("  mk_element: %s [%ld - %ld]\n", pmh_element_name_from_type(type), pos, end);
+    
+    return result;
+}
+
+static pmh_realelement *copy_element(parser_data *p_data, pmh_realelement *elem)
+{
+    pmh_realelement *result = mk_element(p_data, elem->type, elem->pos, elem->end);
+    result->label = strdup_or_null(elem->label);
+    result->text = strdup_or_null(elem->text);
+    result->address = strdup_or_null(elem->address);
+    return result;
+}
+
+/* construct pmh_EXTRA_TEXT pmh_realelement */
+static pmh_realelement *mk_etext(parser_data *p_data, char *string)
+{
+    pmh_realelement *result;
+    assert(string != NULL);
+    result = mk_element(p_data, pmh_EXTRA_TEXT, 0,0);
+    result->text = strdup_or_null(string);
+    return result;
+}
+
+
+/*
+Given an element where the offsets {pos, end} represent
+locations in the *parsed text* (defined by the linked list of pmh_RAW and
+pmh_EXTRA_TEXT elements in p_data->current_elem), fix these offsets to represent
+corresponding offsets in the parse buffer (p_data->charbuf). Also split
+the given pmh_realelement into multiple parts if its offsets span multiple
+p_data->current_elem elements. Return the (list of) elements with real offsets.
+*/
+static pmh_realelement *fix_offsets(parser_data *p_data, pmh_realelement *elem)
+{
+    if (elem->type == pmh_EXTRA_TEXT)
+        return mk_etext(p_data, elem->text);
+    
+    pmh_realelement *new_head = copy_element(p_data, elem);
+    
+    pmh_realelement *tail = new_head;
+    pmh_realelement *prev = NULL;
+    
+    bool found_start = false;
+    bool found_end = false;
+    bool tail_needs_pos = false;
+    unsigned long previous_end = 0;
+    unsigned long c = 0;
+    
+    pmh_realelement *cursor = p_data->elem_head;
+    while (cursor != NULL)
+    {
+        int thislen = (cursor->type == pmh_EXTRA_TEXT)
+                        ? strlen(cursor->text)
+                        : cursor->end - cursor->pos;
+        
+        if (tail_needs_pos && cursor->type != pmh_EXTRA_TEXT) {
+            tail->pos = cursor->pos;
+            tail_needs_pos = false;
+        }
+        
+        unsigned int this_pos = cursor->pos;
+        
+        if (!found_start && (c <= elem->pos && elem->pos <= c+thislen)) {
+            tail->pos = (cursor->type == pmh_EXTRA_TEXT)
+                        ? previous_end
+                        : cursor->pos + (elem->pos - c);
+            this_pos = tail->pos;
+            found_start = true;
+        }
+        
+        if (!found_end && (c <= elem->end && elem->end <= c+thislen)) {
+            tail->end = (cursor->type == pmh_EXTRA_TEXT)
+                        ? previous_end
+                        : cursor->pos + (elem->end - c);
+            found_end = true;
+        }
+        
+        if (found_start && found_end)
+            break;
+        
+        if (cursor->type != pmh_EXTRA_TEXT)
+            previous_end = cursor->end;
+        
+        if (found_start) {
+            pmh_realelement *new_elem = copy_element(p_data, tail);
+            new_elem->pos = this_pos;
+            new_elem->end = cursor->end;
+            new_elem->next = tail;
+            if (prev != NULL)
+                prev->next = new_elem;
+            if (new_head == tail)
+                new_head = new_elem;
+            prev = new_elem;
+            tail_needs_pos = true;
+        }
+        
+        c += thislen;
+        cursor = cursor->next;
+    }
+    
+    return new_head;
+}
+
+
+
+/* Add an element to p_data->head_elems. */
+static void add(parser_data *p_data, pmh_realelement *elem)
+{
+    if (elem->type != pmh_RAW_LIST)
+    {
+        pmh_PRINTF("  add: %s [%ld - %ld]\n",
+                   pmh_element_name_from_type(elem->type), elem->pos, elem->end);
+        elem = fix_offsets(p_data, elem);
+        pmh_PRINTF("     > %s [%ld - %ld]\n",
+                   pmh_element_name_from_type(elem->type), elem->pos, elem->end);
+    }
+    else
+    {
+        pmh_PRINTF("  add: pmh_RAW_LIST ");
+        pmh_realelement *cursor = elem->children;
+        pmh_realelement *previous = NULL;
+        while (cursor != NULL)
+        {
+            pmh_realelement *next = cursor->next;
+            pmh_PRINTF("(%ld-%ld)>", cursor->pos, cursor->end);
+            pmh_realelement *new_cursor = fix_offsets(p_data, cursor);
+            if (previous != NULL)
+                previous->next = new_cursor;
+            else
+                elem->children = new_cursor;
+            pmh_PRINTF("(%ld-%ld)", new_cursor->pos, new_cursor->end);
+            while (new_cursor->next != NULL) {
+                new_cursor = new_cursor->next;
+                pmh_PRINTF("(%ld-%ld)", new_cursor->pos, new_cursor->end);
+            }
+            pmh_PRINTF(" ");
+            if (next != NULL)
+                new_cursor->next = next;
+            previous = new_cursor;
+            cursor = next;
+        }
+        pmh_PRINTF("\n");
+    }
+    
+    if (p_data->head_elems[elem->type] == NULL)
+        p_data->head_elems[elem->type] = elem;
+    else
+    {
+        pmh_realelement *last = elem;
+        while (last->next != NULL)
+            last = last->next;
+        last->next = p_data->head_elems[elem->type];
+        p_data->head_elems[elem->type] = elem;
+    }
+}
+
+
+// Given a range in the list of spans we use for parsing (pos, end), return
+// a copy of the corresponding section in the original input, with all of
+// the UTF-8 bytes intact:
+static char *copy_input_span(parser_data *p_data,
+                             unsigned long pos, unsigned long end)
+{
+    if (end <= pos)
+        return NULL;
+    
+    char *ret = NULL;
+    
+    // Adjust (pos,end) to match actual indexes in charbuf:
+    pmh_realelement *dummy = mk_element(p_data, pmh_NO_TYPE, pos, end);
+    pmh_realelement *fixed_dummies = fix_offsets(p_data, dummy);
+    pmh_realelement *cursor = fixed_dummies;
+    while (cursor != NULL)
+    {
+        if (cursor->end <= cursor->pos)
+        {
+            cursor = cursor->next;
+            continue;
+        }
+        
+        // Adjust cursor's span to take bytes stripped from the original
+        // input into account (i.e. match the corresponding span in
+        // p_data->original_input):
+        unsigned long adjusted_pos = cursor->pos;
+        unsigned long adjusted_end = cursor->end;
+        size_t i;
+        for (i = 0; i < p_data->strip_positions_len; i++)
+        {
+            unsigned long strip_position = p_data->strip_positions[i];
+            if (strip_position <= adjusted_pos)
+                adjusted_pos++;
+            if (strip_position <= adjusted_end)
+                adjusted_end++;
+            else
+                break;
+        }
+        
+        // Copy span from original input:
+        size_t adjusted_len = adjusted_end - adjusted_pos;
+        char *str = (char *)malloc(sizeof(char)*adjusted_len + 1);
+        *str = '\0';
+        strncat(str, (p_data->original_input + adjusted_pos), adjusted_len);
+        
+        if (ret == NULL)
+            ret = str;
+        else
+        {
+            // append str to ret:
+            char *new_ret = (char *)malloc(sizeof(char)
+                                           *(strlen(str) + strlen(ret)) + 1);
+            *new_ret = '\0';
+            strcat(new_ret, ret);
+            strcat(new_ret, str);
+            free(ret);
+            free(str);
+            ret = new_ret;
+        }
+        
+        cursor = cursor->next;
+    }
+    
+    return ret;
+}
+
+
+
+
+
+# define YYSTYPE pmh_realelement *
+#ifdef __DEBUG__
+# define YY_DEBUG 1
+#endif
+
+#define YY_INPUT(buf, result, max_size)\
+        yy_input_func(buf, &result, max_size, (parser_data *)G->data)
+
+static void yy_input_func(char *buf, int *result, int max_size,
+                          parser_data *p_data)
+{
+    if (p_data->current_elem == NULL)
+    {
+        (*result) = 0;
+        return;
+    }
+    
+    if (p_data->current_elem->type == pmh_EXTRA_TEXT)
+    {
+        int yyc;
+        bool moreToRead = (p_data->current_elem->text
+                           && *(p_data->current_elem->text
+                                + p_data->current_elem->text_offset) != '\0');
+        if (moreToRead)
+        {
+            yyc = *(p_data->current_elem->text + p_data->current_elem->text_offset++);
+            pmh_PRINTF("\e[47;30m"); pmh_PUTCHAR(yyc); pmh_PRINTF("\e[0m");
+            pmh_IF(yyc == '\n') pmh_PRINTF("\e[47m \e[0m");
+        }
+        else
+        {
+            yyc = EOF;
+            p_data->current_elem = p_data->current_elem->next;
+            pmh_PRINTF("\e[41m \e[0m");
+            if (p_data->current_elem != NULL)
+                p_data->offset = p_data->current_elem->pos;
+        }
+        (*result) = (EOF == yyc) ? 0 : (*(buf) = yyc, 1);
+        return;
+    }
+    
+    *(buf) = *(p_data->charbuf + p_data->offset);
+    (*result) = (*buf != '\0');
+    p_data->offset++;
+    
+    pmh_PRINTF("\e[43;30m"); pmh_PUTCHAR(*buf); pmh_PRINTF("\e[0m");
+    pmh_IF(*buf == '\n') pmh_PRINTF("\e[42m \e[0m");
+    
+    if (p_data->offset >= p_data->current_elem->end)
+    {
+        p_data->current_elem = p_data->current_elem->next;
+        pmh_PRINTF("\e[41m \e[0m");
+        if (p_data->current_elem != NULL)
+            p_data->offset = p_data->current_elem->pos;
+    }
+}
+
+
+
+#define elem(x)     mk_element((parser_data *)G->data, x, thunk->begin, thunk->end)
+#define elem_s(x)   mk_element((parser_data *)G->data, x, s->pos, thunk->end)
+#define mk_sep      mk_element((parser_data *)G->data, pmh_SEPARATOR, 0,0)
+#define mk_notype   mk_element((parser_data *)G->data, pmh_NO_TYPE, 0,0)
+#define etext(x)    mk_etext((parser_data *)G->data, x)
+#define ADD(x)      add((parser_data *)G->data, x)
+#define EXT(x)      extension((parser_data *)G->data, x)
+#define REF_EXISTS(x) reference_exists((parser_data *)G->data, x)
+#define GET_REF(x)  get_reference((parser_data *)G->data, x)
+#define PARSING_REFERENCES ((parser_data *)G->data)->parsing_only_references
+#define FREE_LABEL(l) { free(l->label); l->label = NULL; }
+#define FREE_ADDRESS(l) { free(l->address); l->address = NULL; }
+
+// This gives us the text matched with < > as it appears in the original input:
+#define COPY_YYTEXT_ORIG() copy_input_span((parser_data *)G->data, thunk->begin, thunk->end)
+
+
+#ifndef YY_ALLOC
+#define YY_ALLOC(N, D) malloc(N)
+#endif
+#ifndef YY_CALLOC
+#define YY_CALLOC(N, S, D) calloc(N, S)
+#endif
+#ifndef YY_REALLOC
+#define YY_REALLOC(B, N, D) realloc(B, N)
+#endif
+#ifndef YY_FREE
+#define YY_FREE free
+#endif
+#ifndef YY_LOCAL
+#define YY_LOCAL(T)     static T
+#endif
+#ifndef YY_ACTION
+#define YY_ACTION(T)    static T
+#endif
+#ifndef YY_RULE
+#define YY_RULE(T)      static T
+#endif
+#ifndef YY_PARSE
+#define YY_PARSE(T)     T
+#endif
+#ifndef YY_NAME
+#define YY_NAME(N) yy##N
+#endif
+#ifndef YY_INPUT
+#define YY_INPUT(buf, result, max_size)                 \
+  {                                                     \
+    int yyc= getchar();                                 \
+    result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1);        \
+    yyprintf((stderr, "<%c>", yyc));                  \
+  }
+#endif
+#ifndef YY_BEGIN
+#define YY_BEGIN        ( G->begin= G->pos, 1)
+#endif
+#ifndef YY_END
+#define YY_END          ( G->end= G->pos, 1)
+#endif
+#ifdef YY_DEBUG
+# define yyprintf(args) fprintf args
+#else
+# define yyprintf(args)
+#endif
+#ifndef YYSTYPE
+#define YYSTYPE int
+#endif
+#ifndef YY_XTYPE
+#define YY_XTYPE void *
+#endif
+#ifndef YY_XVAR
+#define YY_XVAR yyxvar
+#endif
+
+#ifndef YY_STACK_SIZE
+#define YY_STACK_SIZE 128
+#endif
+
+#ifndef YY_BUFFER_START_SIZE
+#define YY_BUFFER_START_SIZE 1024
+#endif
+
+#ifndef YY_PART
+#define yydata G->data
+#define yy G->ss
+
+struct _yythunk; // forward declaration
+typedef void (*yyaction)(struct _GREG *G, char *yytext, int yyleng, struct _yythunk *thunkpos, YY_XTYPE YY_XVAR);
+typedef struct _yythunk { int begin, end;  yyaction  action;  struct _yythunk *next; } yythunk;
+
+typedef struct _GREG {
+  char *buf;
+  int buflen;
+  int   offset;
+  int   pos;
+  int   limit;
+  char *text;
+  int   textlen;
+  int   begin;
+  int   end;
+  yythunk *thunks;
+  int   thunkslen;
+  int thunkpos;
+  YYSTYPE ss;
+  YYSTYPE *val;
+  YYSTYPE *vals;
+  int valslen;
+  YY_XTYPE data;
+} GREG;
+
+YY_LOCAL(int) yyrefill(GREG *G)
+{
+  int yyn;
+  while (G->buflen - G->pos < 512)
+    {
+      G->buflen *= 2;
+      G->buf= (char *)YY_REALLOC(G->buf, G->buflen, G->data);
+    }
+  YY_INPUT((G->buf + G->pos), yyn, (G->buflen - G->pos));
+  if (!yyn) return 0;
+  G->limit += yyn;
+  return 1;
+}
+
+YY_LOCAL(int) yymatchDot(GREG *G)
+{
+  if (G->pos >= G->limit && !yyrefill(G)) return 0;
+  ++G->pos;
+  return 1;
+}
+
+YY_LOCAL(int) yymatchChar(GREG *G, int c)
+{
+  if (G->pos >= G->limit && !yyrefill(G)) return 0;
+  if ((unsigned char)G->buf[G->pos] == c)
+    {
+      ++G->pos;
+      yyprintf((stderr, "  ok   yymatchChar(%c) @ %s\n", c, G->buf+G->pos));
+      return 1;
+    }
+  yyprintf((stderr, "  fail yymatchChar(%c) @ %s\n", c, G->buf+G->pos));
+  return 0;
+}
+
+YY_LOCAL(int) yymatchString(GREG *G, char *s)
+{
+  int yysav= G->pos;
+  while (*s)
+    {
+      if (G->pos >= G->limit && !yyrefill(G)) return 0;
+      if (G->buf[G->pos] != *s)
+        {
+          G->pos= yysav;
+          return 0;
+        }
+      ++s;
+      ++G->pos;
+    }
+  return 1;
+}
+
+YY_LOCAL(int) yymatchClass(GREG *G, unsigned char *bits)
+{
+  int c;
+  if (G->pos >= G->limit && !yyrefill(G)) return 0;
+  c= (unsigned char)G->buf[G->pos];
+  if (bits[c >> 3] & (1 << (c & 7)))
+    {
+      ++G->pos;
+      yyprintf((stderr, "  ok   yymatchClass @ %s\n", G->buf+G->pos));
+      return 1;
+    }
+  yyprintf((stderr, "  fail yymatchClass @ %s\n", G->buf+G->pos));
+  return 0;
+}
+
+YY_LOCAL(void) yyDo(GREG *G, yyaction action, int begin, int end)
+{
+  while (G->thunkpos >= G->thunkslen)
+    {
+      G->thunkslen *= 2;
+      G->thunks= (yythunk *)YY_REALLOC(G->thunks, sizeof(yythunk) * G->thunkslen, G->data);
+    }
+  G->thunks[G->thunkpos].begin=  begin;
+  G->thunks[G->thunkpos].end=    end;
+  G->thunks[G->thunkpos].action= action;
+  ++G->thunkpos;
+}
+
+YY_LOCAL(int) yyText(GREG *G, int begin, int end)
+{
+  int yyleng= end - begin;
+  if (yyleng <= 0)
+    yyleng= 0;
+  else
+    {
+      while (G->textlen < (yyleng + 1))
+        {
+          G->textlen *= 2;
+          G->text= (char *)YY_REALLOC(G->text, G->textlen, G->data);
+        }
+      memcpy(G->text, G->buf + begin, yyleng);
+    }
+  G->text[yyleng]= '\0';
+  return yyleng;
+}
+
+YY_LOCAL(void) yyDone(GREG *G)
+{
+  int pos;
+  for (pos= 0; pos < G->thunkpos; ++pos)
+    {
+      yythunk *thunk= &G->thunks[pos];
+      int yyleng= thunk->end ? yyText(G, thunk->begin, thunk->end) : thunk->begin;
+      yyprintf((stderr, "DO [%d] %p %s\n", pos, thunk->action, G->text));
+      thunk->action(G, G->text, yyleng, thunk, G->data);
+    }
+  G->thunkpos= 0;
+}
+
+YY_LOCAL(void) yyCommit(GREG *G)
+{
+  if ((G->limit -= G->pos))
+    {
+      memmove(G->buf, G->buf + G->pos, G->limit);
+    }
+  G->offset += G->pos;
+  G->begin -= G->pos;
+  G->end -= G->pos;
+  G->pos= G->thunkpos= 0;
+}
+
+YY_LOCAL(int) yyAccept(GREG *G, int tp0)
+{
+  if (tp0)
+    {
+      fprintf(stderr, "accept denied at %d\n", tp0);
+      return 0;
+    }
+  else
+    {
+      yyDone(G);
+      yyCommit(G);
+    }
+  return 1;
+}
+
+YY_LOCAL(void) yyPush(GREG *G, char *text, int count, yythunk *thunk, YY_XTYPE YY_XVAR) { G->val += count; }
+YY_LOCAL(void) yyPop(GREG *G, char *text, int count, yythunk *thunk, YY_XTYPE YY_XVAR)  { G->val -= count; }
+YY_LOCAL(void) yySet(GREG *G, char *text, int count, yythunk *thunk, YY_XTYPE YY_XVAR)  { G->val[count]= G->ss; }
+
+#endif /* YY_PART */
+
+#define YYACCEPT        yyAccept(G, yythunkpos0)
+
+YY_RULE(int) yy_RawNoteBlock(GREG *G); /* 225 */
+YY_RULE(int) yy_RawNoteReference(GREG *G); /* 224 */
+YY_RULE(int) yy_ExtendedSpecialChar(GREG *G); /* 223 */
+YY_RULE(int) yy_AlphanumericAscii(GREG *G); /* 222 */
+YY_RULE(int) yy_Quoted(GREG *G); /* 221 */
+YY_RULE(int) yy_HtmlTag(GREG *G); /* 220 */
+YY_RULE(int) yy_Ticks5(GREG *G); /* 219 */
+YY_RULE(int) yy_Ticks4(GREG *G); /* 218 */
+YY_RULE(int) yy_Ticks3(GREG *G); /* 217 */
+YY_RULE(int) yy_Ticks2(GREG *G); /* 216 */
+YY_RULE(int) yy_Ticks1(GREG *G); /* 215 */
+YY_RULE(int) yy_SkipBlock(GREG *G); /* 214 */
+YY_RULE(int) yy_References(GREG *G); /* 213 */
+YY_RULE(int) yy_EmptyTitle(GREG *G); /* 212 */
+YY_RULE(int) yy_RefTitleParens(GREG *G); /* 211 */
+YY_RULE(int) yy_RefTitleDouble(GREG *G); /* 210 */
+YY_RULE(int) yy_RefTitleSingle(GREG *G); /* 209 */
+YY_RULE(int) yy_RefTitle(GREG *G); /* 208 */
+YY_RULE(int) yy_RefSrc(GREG *G); /* 207 */
+YY_RULE(int) yy_AutoLinkEmail(GREG *G); /* 206 */
+YY_RULE(int) yy_AutoLinkUrl(GREG *G); /* 205 */
+YY_RULE(int) yy_TitleDouble(GREG *G); /* 204 */
+YY_RULE(int) yy_TitleSingle(GREG *G); /* 203 */
+YY_RULE(int) yy_Nonspacechar(GREG *G); /* 202 */
+YY_RULE(int) yy_SourceContents(GREG *G); /* 201 */
+YY_RULE(int) yy_Title(GREG *G); /* 200 */
+YY_RULE(int) yy_Source(GREG *G); /* 199 */
+YY_RULE(int) yy_Label(GREG *G); /* 198 */
+YY_RULE(int) yy_ReferenceLinkSingle(GREG *G); /* 197 */
+YY_RULE(int) yy_ReferenceLinkDouble(GREG *G); /* 196 */
+YY_RULE(int) yy_AutoLink(GREG *G); /* 195 */
+YY_RULE(int) yy_ReferenceLink(GREG *G); /* 194 */
+YY_RULE(int) yy_ExplicitLink(GREG *G); /* 193 */
+YY_RULE(int) yy_StrongUl(GREG *G); /* 192 */
+YY_RULE(int) yy_StrongStar(GREG *G); /* 191 */
+YY_RULE(int) yy_Whitespace(GREG *G); /* 190 */
+YY_RULE(int) yy_EmphUl(GREG *G); /* 189 */
+YY_RULE(int) yy_EmphStar(GREG *G); /* 188 */
+YY_RULE(int) yy_StarLine(GREG *G); /* 187 */
+YY_RULE(int) yy_UlLine(GREG *G); /* 186 */
+YY_RULE(int) yy_SpecialChar(GREG *G); /* 185 */
+YY_RULE(int) yy_Eof(GREG *G); /* 184 */
+YY_RULE(int) yy_NormalEndline(GREG *G); /* 183 */
+YY_RULE(int) yy_TerminalEndline(GREG *G); /* 182 */
+YY_RULE(int) yy_LineBreak(GREG *G); /* 181 */
+YY_RULE(int) yy_CharEntity(GREG *G); /* 180 */
+YY_RULE(int) yy_DecEntity(GREG *G); /* 179 */
+YY_RULE(int) yy_HexEntity(GREG *G); /* 178 */
+YY_RULE(int) yy_Alphanumeric(GREG *G); /* 177 */
+YY_RULE(int) yy_NormalChar(GREG *G); /* 176 */
+YY_RULE(int) yy_Symbol(GREG *G); /* 175 */
+YY_RULE(int) yy_EscapedChar(GREG *G); /* 174 */
+YY_RULE(int) yy_Entity(GREG *G); /* 173 */
+YY_RULE(int) yy_RawHtml(GREG *G); /* 172 */
+YY_RULE(int) yy_Code(GREG *G); /* 171 */
+YY_RULE(int) yy_InlineNote(GREG *G); /* 170 */
+YY_RULE(int) yy_NoteReference(GREG *G); /* 169 */
+YY_RULE(int) yy_Link(GREG *G); /* 168 */
+YY_RULE(int) yy_Image(GREG *G); /* 167 */
+YY_RULE(int) yy_Strike(GREG *G); /* 166 */
+YY_RULE(int) yy_Emph(GREG *G); /* 165 */
+YY_RULE(int) yy_Strong(GREG *G); /* 164 */
+YY_RULE(int) yy_Space(GREG *G); /* 163 */
+YY_RULE(int) yy_UlOrStarLine(GREG *G); /* 162 */
+YY_RULE(int) yy_Str(GREG *G); /* 161 */
+YY_RULE(int) yy_InStyleTags(GREG *G); /* 160 */
+YY_RULE(int) yy_StyleClose(GREG *G); /* 159 */
+YY_RULE(int) yy_StyleOpen(GREG *G); /* 158 */
+YY_RULE(int) yy_HtmlBlockType(GREG *G); /* 157 */
+YY_RULE(int) yy_HtmlBlockSelfClosing(GREG *G); /* 156 */
+YY_RULE(int) yy_HtmlComment(GREG *G); /* 155 */
+YY_RULE(int) yy_HtmlBlockInTags(GREG *G); /* 154 */
+YY_RULE(int) yy_HtmlBlockHead(GREG *G); /* 153 */
+YY_RULE(int) yy_HtmlBlockCloseHead(GREG *G); /* 152 */
+YY_RULE(int) yy_HtmlBlockOpenHead(GREG *G); /* 151 */
+YY_RULE(int) yy_HtmlBlockScript(GREG *G); /* 150 */
+YY_RULE(int) yy_HtmlBlockCloseScript(GREG *G); /* 149 */
+YY_RULE(int) yy_HtmlBlockOpenScript(GREG *G); /* 148 */
+YY_RULE(int) yy_HtmlBlockTr(GREG *G); /* 147 */
+YY_RULE(int) yy_HtmlBlockCloseTr(GREG *G); /* 146 */
+YY_RULE(int) yy_HtmlBlockOpenTr(GREG *G); /* 145 */
+YY_RULE(int) yy_HtmlBlockThead(GREG *G); /* 144 */
+YY_RULE(int) yy_HtmlBlockCloseThead(GREG *G); /* 143 */
+YY_RULE(int) yy_HtmlBlockOpenThead(GREG *G); /* 142 */
+YY_RULE(int) yy_HtmlBlockTh(GREG *G); /* 141 */
+YY_RULE(int) yy_HtmlBlockCloseTh(GREG *G); /* 140 */
+YY_RULE(int) yy_HtmlBlockOpenTh(GREG *G); /* 139 */
+YY_RULE(int) yy_HtmlBlockTfoot(GREG *G); /* 138 */
+YY_RULE(int) yy_HtmlBlockCloseTfoot(GREG *G); /* 137 */
+YY_RULE(int) yy_HtmlBlockOpenTfoot(GREG *G); /* 136 */
+YY_RULE(int) yy_HtmlBlockTd(GREG *G); /* 135 */
+YY_RULE(int) yy_HtmlBlockCloseTd(GREG *G); /* 134 */
+YY_RULE(int) yy_HtmlBlockOpenTd(GREG *G); /* 133 */
+YY_RULE(int) yy_HtmlBlockTbody(GREG *G); /* 132 */
+YY_RULE(int) yy_HtmlBlockCloseTbody(GREG *G); /* 131 */
+YY_RULE(int) yy_HtmlBlockOpenTbody(GREG *G); /* 130 */
+YY_RULE(int) yy_HtmlBlockLi(GREG *G); /* 129 */
+YY_RULE(int) yy_HtmlBlockCloseLi(GREG *G); /* 128 */
+YY_RULE(int) yy_HtmlBlockOpenLi(GREG *G); /* 127 */
+YY_RULE(int) yy_HtmlBlockFrameset(GREG *G); /* 126 */
+YY_RULE(int) yy_HtmlBlockCloseFrameset(GREG *G); /* 125 */
+YY_RULE(int) yy_HtmlBlockOpenFrameset(GREG *G); /* 124 */
+YY_RULE(int) yy_HtmlBlockDt(GREG *G); /* 123 */
+YY_RULE(int) yy_HtmlBlockCloseDt(GREG *G); /* 122 */
+YY_RULE(int) yy_HtmlBlockOpenDt(GREG *G); /* 121 */
+YY_RULE(int) yy_HtmlBlockDd(GREG *G); /* 120 */
+YY_RULE(int) yy_HtmlBlockCloseDd(GREG *G); /* 119 */
+YY_RULE(int) yy_HtmlBlockOpenDd(GREG *G); /* 118 */
+YY_RULE(int) yy_HtmlBlockUl(GREG *G); /* 117 */
+YY_RULE(int) yy_HtmlBlockCloseUl(GREG *G); /* 116 */
+YY_RULE(int) yy_HtmlBlockOpenUl(GREG *G); /* 115 */
+YY_RULE(int) yy_HtmlBlockTable(GREG *G); /* 114 */
+YY_RULE(int) yy_HtmlBlockCloseTable(GREG *G); /* 113 */
+YY_RULE(int) yy_HtmlBlockOpenTable(GREG *G); /* 112 */
+YY_RULE(int) yy_HtmlBlockPre(GREG *G); /* 111 */
+YY_RULE(int) yy_HtmlBlockClosePre(GREG *G); /* 110 */
+YY_RULE(int) yy_HtmlBlockOpenPre(GREG *G); /* 109 */
+YY_RULE(int) yy_HtmlBlockP(GREG *G); /* 108 */
+YY_RULE(int) yy_HtmlBlockCloseP(GREG *G); /* 107 */
+YY_RULE(int) yy_HtmlBlockOpenP(GREG *G); /* 106 */
+YY_RULE(int) yy_HtmlBlockOl(GREG *G); /* 105 */
+YY_RULE(int) yy_HtmlBlockCloseOl(GREG *G); /* 104 */
+YY_RULE(int) yy_HtmlBlockOpenOl(GREG *G); /* 103 */
+YY_RULE(int) yy_HtmlBlockNoscript(GREG *G); /* 102 */
+YY_RULE(int) yy_HtmlBlockCloseNoscript(GREG *G); /* 101 */
+YY_RULE(int) yy_HtmlBlockOpenNoscript(GREG *G); /* 100 */
+YY_RULE(int) yy_HtmlBlockNoframes(GREG *G); /* 99 */
+YY_RULE(int) yy_HtmlBlockCloseNoframes(GREG *G); /* 98 */
+YY_RULE(int) yy_HtmlBlockOpenNoframes(GREG *G); /* 97 */
+YY_RULE(int) yy_HtmlBlockMenu(GREG *G); /* 96 */
+YY_RULE(int) yy_HtmlBlockCloseMenu(GREG *G); /* 95 */
+YY_RULE(int) yy_HtmlBlockOpenMenu(GREG *G); /* 94 */
+YY_RULE(int) yy_HtmlBlockH6(GREG *G); /* 93 */
+YY_RULE(int) yy_HtmlBlockCloseH6(GREG *G); /* 92 */
+YY_RULE(int) yy_HtmlBlockOpenH6(GREG *G); /* 91 */
+YY_RULE(int) yy_HtmlBlockH5(GREG *G); /* 90 */
+YY_RULE(int) yy_HtmlBlockCloseH5(GREG *G); /* 89 */
+YY_RULE(int) yy_HtmlBlockOpenH5(GREG *G); /* 88 */
+YY_RULE(int) yy_HtmlBlockH4(GREG *G); /* 87 */
+YY_RULE(int) yy_HtmlBlockCloseH4(GREG *G); /* 86 */
+YY_RULE(int) yy_HtmlBlockOpenH4(GREG *G); /* 85 */
+YY_RULE(int) yy_HtmlBlockH3(GREG *G); /* 84 */
+YY_RULE(int) yy_HtmlBlockCloseH3(GREG *G); /* 83 */
+YY_RULE(int) yy_HtmlBlockOpenH3(GREG *G); /* 82 */
+YY_RULE(int) yy_HtmlBlockH2(GREG *G); /* 81 */
+YY_RULE(int) yy_HtmlBlockCloseH2(GREG *G); /* 80 */
+YY_RULE(int) yy_HtmlBlockOpenH2(GREG *G); /* 79 */
+YY_RULE(int) yy_HtmlBlockH1(GREG *G); /* 78 */
+YY_RULE(int) yy_HtmlBlockCloseH1(GREG *G); /* 77 */
+YY_RULE(int) yy_HtmlBlockOpenH1(GREG *G); /* 76 */
+YY_RULE(int) yy_HtmlBlockForm(GREG *G); /* 75 */
+YY_RULE(int) yy_HtmlBlockCloseForm(GREG *G); /* 74 */
+YY_RULE(int) yy_HtmlBlockOpenForm(GREG *G); /* 73 */
+YY_RULE(int) yy_HtmlBlockFieldset(GREG *G); /* 72 */
+YY_RULE(int) yy_HtmlBlockCloseFieldset(GREG *G); /* 71 */
+YY_RULE(int) yy_HtmlBlockOpenFieldset(GREG *G); /* 70 */
+YY_RULE(int) yy_HtmlBlockDl(GREG *G); /* 69 */
+YY_RULE(int) yy_HtmlBlockCloseDl(GREG *G); /* 68 */
+YY_RULE(int) yy_HtmlBlockOpenDl(GREG *G); /* 67 */
+YY_RULE(int) yy_HtmlBlockDiv(GREG *G); /* 66 */
+YY_RULE(int) yy_HtmlBlockCloseDiv(GREG *G); /* 65 */
+YY_RULE(int) yy_HtmlBlockOpenDiv(GREG *G); /* 64 */
+YY_RULE(int) yy_HtmlBlockDir(GREG *G); /* 63 */
+YY_RULE(int) yy_HtmlBlockCloseDir(GREG *G); /* 62 */
+YY_RULE(int) yy_HtmlBlockOpenDir(GREG *G); /* 61 */
+YY_RULE(int) yy_HtmlBlockCenter(GREG *G); /* 60 */
+YY_RULE(int) yy_HtmlBlockCloseCenter(GREG *G); /* 59 */
+YY_RULE(int) yy_HtmlBlockOpenCenter(GREG *G); /* 58 */
+YY_RULE(int) yy_HtmlBlockBlockquote(GREG *G); /* 57 */
+YY_RULE(int) yy_HtmlBlockCloseBlockquote(GREG *G); /* 56 */
+YY_RULE(int) yy_HtmlBlockOpenBlockquote(GREG *G); /* 55 */
+YY_RULE(int) yy_HtmlBlockAddress(GREG *G); /* 54 */
+YY_RULE(int) yy_HtmlBlockCloseAddress(GREG *G); /* 53 */
+YY_RULE(int) yy_HtmlAttribute(GREG *G); /* 52 */
+YY_RULE(int) yy_Spnl(GREG *G); /* 51 */
+YY_RULE(int) yy_HtmlBlockOpenAddress(GREG *G); /* 50 */
+YY_RULE(int) yy_OptionallyIndentedLine(GREG *G); /* 49 */
+YY_RULE(int) yy_Indent(GREG *G); /* 48 */
+YY_RULE(int) yy_ListBlockLine(GREG *G); /* 47 */
+YY_RULE(int) yy_ListContinuationBlock(GREG *G); /* 46 */
+YY_RULE(int) yy_ListBlock(GREG *G); /* 45 */
+YY_RULE(int) yy_ListItem(GREG *G); /* 44 */
+YY_RULE(int) yy_Enumerator(GREG *G); /* 43 */
+YY_RULE(int) yy_ListItemTight(GREG *G); /* 42 */
+YY_RULE(int) yy_ListLoose(GREG *G); /* 41 */
+YY_RULE(int) yy_ListTight(GREG *G); /* 40 */
+YY_RULE(int) yy_Spacechar(GREG *G); /* 39 */
+YY_RULE(int) yy_Bullet(GREG *G); /* 38 */
+YY_RULE(int) yy_VerbatimChunk(GREG *G); /* 37 */
+YY_RULE(int) yy_IndentedLine(GREG *G); /* 36 */
+YY_RULE(int) yy_NonblankIndentedLine(GREG *G); /* 35 */
+YY_RULE(int) yy_Line(GREG *G); /* 34 */
+YY_RULE(int) yy_StartList(GREG *G); /* 33 */
+YY_RULE(int) yy_BlockQuoteRaw(GREG *G); /* 32 */
+YY_RULE(int) yy_Endline(GREG *G); /* 31 */
+YY_RULE(int) yy_RawLine(GREG *G); /* 30 */
+YY_RULE(int) yy_SetextBottom2(GREG *G); /* 29 */
+YY_RULE(int) yy_SetextBottom1(GREG *G); /* 28 */
+YY_RULE(int) yy_SetextHeading2(GREG *G); /* 27 */
+YY_RULE(int) yy_SetextHeading1(GREG *G); /* 26 */
+YY_RULE(int) yy_SetextHeading(GREG *G); /* 25 */
+YY_RULE(int) yy_AtxHeading(GREG *G); /* 24 */
+YY_RULE(int) yy_AtxStart(GREG *G); /* 23 */
+YY_RULE(int) yy_Inline(GREG *G); /* 22 */
+YY_RULE(int) yy_Sp(GREG *G); /* 21 */
+YY_RULE(int) yy_Newline(GREG *G); /* 20 */
+YY_RULE(int) yy_AtxInline(GREG *G); /* 19 */
+YY_RULE(int) yy_Inlines(GREG *G); /* 18 */
+YY_RULE(int) yy_NonindentSpace(GREG *G); /* 17 */
+YY_RULE(int) yy_Plain(GREG *G); /* 16 */
+YY_RULE(int) yy_Para(GREG *G); /* 15 */
+YY_RULE(int) yy_StyleBlock(GREG *G); /* 14 */
+YY_RULE(int) yy_HtmlBlock(GREG *G); /* 13 */
+YY_RULE(int) yy_BulletList(GREG *G); /* 12 */
+YY_RULE(int) yy_OrderedList(GREG *G); /* 11 */
+YY_RULE(int) yy_Heading(GREG *G); /* 10 */
+YY_RULE(int) yy_HorizontalRule(GREG *G); /* 9 */
+YY_RULE(int) yy_Reference(GREG *G); /* 8 */
+YY_RULE(int) yy_Note(GREG *G); /* 7 */
+YY_RULE(int) yy_Verbatim(GREG *G); /* 6 */
+YY_RULE(int) yy_BlockQuote(GREG *G); /* 5 */
+YY_RULE(int) yy_BlankLine(GREG *G); /* 4 */
+YY_RULE(int) yy_LocMarker(GREG *G); /* 3 */
+YY_RULE(int) yy_Block(GREG *G); /* 2 */
+YY_RULE(int) yy_Doc(GREG *G); /* 1 */
+
+YY_ACTION(void) yy_1_RawLine(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_RawLine\n"));
+   yy = elem(pmh_RAW); ;
+}
+YY_ACTION(void) yy_1_Line(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Line\n"));
+   yy = mk_element((parser_data *)G->data, pmh_RAW, yy->pos, yy->end); ;
+}
+YY_ACTION(void) yy_1_StartList(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_StartList\n"));
+   yy = NULL; ;
+}
+YY_ACTION(void) yy_1_HtmlComment(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlComment\n"));
+   ADD(elem_s(pmh_COMMENT)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_RawHtml(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_RawHtml\n"));
+   ADD(elem_s(pmh_HTML)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_Code(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_Code\n"));
+   ADD(elem_s(pmh_CODE)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_Ticks5(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Ticks5\n"));
+   yy = elem(pmh_NO_TYPE); ;
+}
+YY_ACTION(void) yy_1_Ticks4(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Ticks4\n"));
+   yy = elem(pmh_NO_TYPE); ;
+}
+YY_ACTION(void) yy_1_Ticks3(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Ticks3\n"));
+   yy = elem(pmh_NO_TYPE); ;
+}
+YY_ACTION(void) yy_1_Ticks2(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Ticks2\n"));
+   yy = elem(pmh_NO_TYPE); ;
+}
+YY_ACTION(void) yy_1_Ticks1(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Ticks1\n"));
+   yy = elem(pmh_NO_TYPE); ;
+}
+YY_ACTION(void) yy_1_RefSrc(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_RefSrc\n"));
+   yy = mk_notype; yy->address = COPY_YYTEXT_ORIG(); ;
+}
+YY_ACTION(void) yy_2_Label(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_2_Label\n"));
+  
+            s->pos = s->pos;
+            s->end = thunk->end;
+            yy = s;
+        ;
+#undef s
+}
+YY_ACTION(void) yy_1_Label(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_Label\n"));
+   s->label = COPY_YYTEXT_ORIG(); ;
+#undef s
+}
+YY_ACTION(void) yy_1_Reference(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define r G->val[-1]
+#define l G->val[-2]
+#define s G->val[-3]
+  yyprintf((stderr, "do yy_1_Reference\n"));
+  
+                pmh_realelement *el = elem_s(pmh_REFERENCE);
+                el->label = strdup_or_null(l->label);
+                el->address = strdup_or_null(r->address);
+                ADD(el);
+                FREE_LABEL(l);
+                FREE_ADDRESS(r);
+              ;
+#undef r
+#undef l
+#undef s
+}
+YY_ACTION(void) yy_3_AutoLinkEmail(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_3_AutoLinkEmail\n"));
+  
+                s->end = thunk->end;
+                ADD(s);
+               ;
+#undef s
+}
+YY_ACTION(void) yy_2_AutoLinkEmail(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_2_AutoLinkEmail\n"));
+   s->address = COPY_YYTEXT_ORIG(); ;
+#undef s
+}
+YY_ACTION(void) yy_1_AutoLinkEmail(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_AutoLinkEmail\n"));
+   s->type = pmh_AUTO_LINK_EMAIL; ;
+#undef s
+}
+YY_ACTION(void) yy_3_AutoLinkUrl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_3_AutoLinkUrl\n"));
+  
+                s->end = thunk->end;
+                ADD(s);
+               ;
+#undef s
+}
+YY_ACTION(void) yy_2_AutoLinkUrl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_2_AutoLinkUrl\n"));
+   s->address = COPY_YYTEXT_ORIG(); ;
+#undef s
+}
+YY_ACTION(void) yy_1_AutoLinkUrl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_AutoLinkUrl\n"));
+   s->type = pmh_AUTO_LINK_URL; ;
+#undef s
+}
+YY_ACTION(void) yy_3_Source(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_3_Source\n"));
+   yy->address = COPY_YYTEXT_ORIG(); ;
+}
+YY_ACTION(void) yy_2_Source(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_2_Source\n"));
+   yy->address = COPY_YYTEXT_ORIG(); ;
+}
+YY_ACTION(void) yy_1_Source(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Source\n"));
+   yy = mk_notype; ;
+}
+YY_ACTION(void) yy_1_ExplicitLink(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define l G->val[-1]
+#define s G->val[-2]
+  yyprintf((stderr, "do yy_1_ExplicitLink\n"));
+  
+                    yy = elem_s(pmh_LINK);
+                    if (l->address != NULL)
+                        yy->address = strdup_or_null(l->address);
+                    FREE_LABEL(s);
+                    FREE_ADDRESS(l);
+                ;
+#undef l
+#undef s
+}
+YY_ACTION(void) yy_1_ReferenceLinkSingle(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_ReferenceLinkSingle\n"));
+  
+                        	pmh_realelement *reference = GET_REF(s->label);
+                            if (reference) {
+                                yy = elem_s(pmh_LINK);
+                                yy->label = strdup_or_null(s->label);
+                                yy->address = strdup_or_null(reference->address);
+                            } else
+                                yy = NULL;
+                            FREE_LABEL(s);
+                        ;
+#undef s
+}
+YY_ACTION(void) yy_1_ReferenceLinkDouble(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define l G->val[-1]
+#define s G->val[-2]
+  yyprintf((stderr, "do yy_1_ReferenceLinkDouble\n"));
+  
+                        	pmh_realelement *reference = GET_REF(l->label);
+                            if (reference) {
+                                yy = elem_s(pmh_LINK);
+                                yy->label = strdup_or_null(l->label);
+                                yy->address = strdup_or_null(reference->address);
+                            } else
+                                yy = NULL;
+                            FREE_LABEL(s);
+                            FREE_LABEL(l);
+                        ;
+#undef l
+#undef s
+}
+YY_ACTION(void) yy_1_Link(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Link\n"));
+   if (yy) ADD(yy); ;
+}
+YY_ACTION(void) yy_1_Image(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Image\n"));
+  
+            if (yy != NULL) {
+                yy->type = pmh_IMAGE;
+                yy->pos -= 1;
+                ADD(yy);
+            }
+        ;
+}
+YY_ACTION(void) yy_1_Strike(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_Strike\n"));
+   ADD(elem_s(pmh_STRIKE)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_StrongUl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_StrongUl\n"));
+   ADD(elem_s(pmh_STRONG)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_StrongStar(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_StrongStar\n"));
+   ADD(elem_s(pmh_STRONG)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_EmphUl(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_EmphUl\n"));
+   ADD(elem_s(pmh_EMPH)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_EmphStar(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_EmphStar\n"));
+   ADD(elem_s(pmh_EMPH)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_Entity(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_Entity\n"));
+   ADD(elem_s(pmh_HTML_ENTITY)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_StyleBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_StyleBlock\n"));
+   ADD(elem_s(pmh_HTMLBLOCK)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_HtmlBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlBlock\n"));
+   ADD(elem_s(pmh_HTMLBLOCK)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_HtmlBlockH6(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlBlockH6\n"));
+   ADD(elem_s(pmh_H6)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_HtmlBlockH5(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlBlockH5\n"));
+   ADD(elem_s(pmh_H5)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_HtmlBlockH4(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlBlockH4\n"));
+   ADD(elem_s(pmh_H4)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_HtmlBlockH3(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlBlockH3\n"));
+   ADD(elem_s(pmh_H3)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_HtmlBlockH2(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlBlockH2\n"));
+   ADD(elem_s(pmh_H2)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_HtmlBlockH1(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_HtmlBlockH1\n"));
+   ADD(elem_s(pmh_H1)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_Enumerator(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Enumerator\n"));
+   ADD(elem(pmh_LIST_ENUMERATOR)); ;
+}
+YY_ACTION(void) yy_3_ListContinuationBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_3_ListContinuationBlock\n"));
+   yy = a; ;
+#undef a
+}
+YY_ACTION(void) yy_2_ListContinuationBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_2_ListContinuationBlock\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_1_ListContinuationBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_1_ListContinuationBlock\n"));
+   if (*yytext == '\0') /* if strlen(yytext) == 0 */
+                                a = cons(elem(pmh_SEPARATOR), a);
+                            else
+                                a = cons(elem(pmh_RAW), a);
+                          ;
+#undef a
+}
+YY_ACTION(void) yy_3_ListBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_3_ListBlock\n"));
+   yy = a; ;
+#undef a
+}
+YY_ACTION(void) yy_2_ListBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_2_ListBlock\n"));
+   a = cons(elem(pmh_RAW), a); ;
+#undef a
+}
+YY_ACTION(void) yy_1_ListBlock(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_1_ListBlock\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_3_ListItemTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_3_ListItemTight\n"));
+   yy = a; ;
+#undef a
+}
+YY_ACTION(void) yy_2_ListItemTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_2_ListItemTight\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_1_ListItemTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_1_ListItemTight\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_3_ListItem(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_3_ListItem\n"));
+   yy = a; ;
+#undef a
+}
+YY_ACTION(void) yy_2_ListItem(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_2_ListItem\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_1_ListItem(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_1_ListItem\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_2_ListLoose(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define b G->val[-1]
+#define a G->val[-2]
+  yyprintf((stderr, "do yy_2_ListLoose\n"));
+   pmh_realelement *cur = a;
+              while (cur != NULL) {
+                  pmh_realelement *rawlist = mk_element((parser_data *)G->data, pmh_RAW_LIST, 0,0);
+                  rawlist->children = reverse(cur->children);
+                  ADD(rawlist);
+                  cur = cur->next;
+              }
+            ;
+#undef b
+#undef a
+}
+YY_ACTION(void) yy_1_ListLoose(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define b G->val[-1]
+#define a G->val[-2]
+  yyprintf((stderr, "do yy_1_ListLoose\n"));
+   b = cons(etext("\n\n"), b); /* In loose list, \n\n added to end of each element */
+                pmh_realelement *el = mk_notype;
+                el->children = b;
+                a = cons(el, a);
+              ;
+#undef b
+#undef a
+}
+YY_ACTION(void) yy_2_ListTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_2_ListTight\n"));
+   pmh_realelement *cur = a;
+              while (cur != NULL) {
+                  pmh_realelement *rawlist = mk_element((parser_data *)G->data, pmh_RAW_LIST, 0,0);
+                  rawlist->children = reverse(cur->children);
+                  ADD(rawlist);
+                  cur = cur->next;
+              }
+            ;
+#undef a
+}
+YY_ACTION(void) yy_1_ListTight(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_1_ListTight\n"));
+   pmh_realelement *el = mk_notype;
+                el->children = yy;
+                a = cons(el, a);
+              ;
+#undef a
+}
+YY_ACTION(void) yy_1_Bullet(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_Bullet\n"));
+   ADD(elem(pmh_LIST_BULLET)); ;
+}
+YY_ACTION(void) yy_1_HorizontalRule(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_HorizontalRule\n"));
+   ADD(elem(pmh_HRULE)); ;
+}
+YY_ACTION(void) yy_1_Verbatim(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_Verbatim\n"));
+   ADD(elem_s(pmh_VERBATIM)); ;
+#undef s
+}
+YY_ACTION(void) yy_5_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_5_BlockQuoteRaw\n"));
+   yy = a; ;
+#undef a
+}
+YY_ACTION(void) yy_4_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_4_BlockQuoteRaw\n"));
+   a = cons(etext("\n"), a); ;
+#undef a
+}
+YY_ACTION(void) yy_3_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_3_BlockQuoteRaw\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_2_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_2_BlockQuoteRaw\n"));
+   a = cons(yy, a); ;
+#undef a
+}
+YY_ACTION(void) yy_1_BlockQuoteRaw(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_1_BlockQuoteRaw\n"));
+   ADD(elem(pmh_BLOCKQUOTE)); ;
+#undef a
+}
+YY_ACTION(void) yy_1_BlockQuote(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define a G->val[-1]
+  yyprintf((stderr, "do yy_1_BlockQuote\n"));
+   pmh_realelement *rawlist = mk_element((parser_data *)G->data, pmh_RAW_LIST, 0,0);
+              rawlist->children = reverse(a);
+              ADD(rawlist);
+            ;
+#undef a
+}
+YY_ACTION(void) yy_1_SetextHeading2(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_SetextHeading2\n"));
+   ADD(elem_s(pmh_H2)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_SetextHeading1(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_SetextHeading1\n"));
+   ADD(elem_s(pmh_H1)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_AtxHeading(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+#define s G->val[-1]
+  yyprintf((stderr, "do yy_1_AtxHeading\n"));
+   ADD(elem_s(s->type)); ;
+#undef s
+}
+YY_ACTION(void) yy_1_AtxStart(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_AtxStart\n"));
+   yy = elem((pmh_element_type)(pmh_H1 + (strlen(yytext) - 1))); ;
+}
+YY_ACTION(void) yy_1_LocMarker(GREG *G, char *yytext, int yyleng, yythunk *thunk, YY_XTYPE YY_XVAR)
+{
+  yyprintf((stderr, "do yy_1_LocMarker\n"));
+   yy = elem(pmh_NO_TYPE); ;
+}
+
+YY_RULE(int) yy_RawNoteBlock(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RawNoteBlock"));
+  {  int yypos4= G->pos, yythunkpos4= G->thunkpos;  if (!yy_BlankLine(G)) { goto l4; }  goto l1;
+  l4:;	  G->pos= yypos4; G->thunkpos= yythunkpos4;
+  }  if (!yy_OptionallyIndentedLine(G)) { goto l1; }
+  l2:;	
+  {  int yypos3= G->pos, yythunkpos3= G->thunkpos;
+  {  int yypos5= G->pos, yythunkpos5= G->thunkpos;  if (!yy_BlankLine(G)) { goto l5; }  goto l3;
+  l5:;	  G->pos= yypos5; G->thunkpos= yythunkpos5;
+  }  if (!yy_OptionallyIndentedLine(G)) { goto l3; }  goto l2;
+  l3:;	  G->pos= yypos3; G->thunkpos= yythunkpos3;
+  }
+  l6:;	
+  {  int yypos7= G->pos, yythunkpos7= G->thunkpos;  if (!yy_BlankLine(G)) { goto l7; }  goto l6;
+  l7:;	  G->pos= yypos7; G->thunkpos= yythunkpos7;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "RawNoteBlock", G->buf+G->pos));
+  return 1;
+  l1:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RawNoteBlock", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RawNoteReference(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RawNoteReference"));  if (!yymatchString(G, "[^")) goto l8;
+  {  int yypos11= G->pos, yythunkpos11= G->thunkpos;  if (!yy_Newline(G)) { goto l11; }  goto l8;
+  l11:;	  G->pos= yypos11; G->thunkpos= yythunkpos11;
+  }
+  {  int yypos12= G->pos, yythunkpos12= G->thunkpos;  if (!yymatchChar(G, ']')) goto l12;  goto l8;
+  l12:;	  G->pos= yypos12; G->thunkpos= yythunkpos12;
+  }  if (!yymatchDot(G)) goto l8;
+  l9:;	
+  {  int yypos10= G->pos, yythunkpos10= G->thunkpos;
+  {  int yypos13= G->pos, yythunkpos13= G->thunkpos;  if (!yy_Newline(G)) { goto l13; }  goto l10;
+  l13:;	  G->pos= yypos13; G->thunkpos= yythunkpos13;
+  }
+  {  int yypos14= G->pos, yythunkpos14= G->thunkpos;  if (!yymatchChar(G, ']')) goto l14;  goto l10;
+  l14:;	  G->pos= yypos14; G->thunkpos= yythunkpos14;
+  }  if (!yymatchDot(G)) goto l10;  goto l9;
+  l10:;	  G->pos= yypos10; G->thunkpos= yythunkpos10;
+  }  if (!yymatchChar(G, ']')) goto l8;
+  yyprintf((stderr, "  ok   %s @ %s\n", "RawNoteReference", G->buf+G->pos));
+  return 1;
+  l8:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RawNoteReference", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ExtendedSpecialChar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "ExtendedSpecialChar"));  yyText(G, G->begin, G->end);  if (!( EXT(pmh_EXT_NOTES) )) goto l15;  if (!yymatchChar(G, '^')) goto l15;
+  yyprintf((stderr, "  ok   %s @ %s\n", "ExtendedSpecialChar", G->buf+G->pos));
+  return 1;
+  l15:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ExtendedSpecialChar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_AlphanumericAscii(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "AlphanumericAscii"));  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l16;
+  yyprintf((stderr, "  ok   %s @ %s\n", "AlphanumericAscii", G->buf+G->pos));
+  return 1;
+  l16:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "AlphanumericAscii", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Quoted(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Quoted"));
+  {  int yypos18= G->pos, yythunkpos18= G->thunkpos;  if (!yymatchChar(G, '"')) goto l19;
+  l20:;	
+  {  int yypos21= G->pos, yythunkpos21= G->thunkpos;
+  {  int yypos22= G->pos, yythunkpos22= G->thunkpos;  if (!yymatchChar(G, '"')) goto l22;  goto l21;
+  l22:;	  G->pos= yypos22; G->thunkpos= yythunkpos22;
+  }  if (!yymatchDot(G)) goto l21;  goto l20;
+  l21:;	  G->pos= yypos21; G->thunkpos= yythunkpos21;
+  }  if (!yymatchChar(G, '"')) goto l19;  goto l18;
+  l19:;	  G->pos= yypos18; G->thunkpos= yythunkpos18;  if (!yymatchChar(G, '\'')) goto l17;
+  l23:;	
+  {  int yypos24= G->pos, yythunkpos24= G->thunkpos;
+  {  int yypos25= G->pos, yythunkpos25= G->thunkpos;  if (!yymatchChar(G, '\'')) goto l25;  goto l24;
+  l25:;	  G->pos= yypos25; G->thunkpos= yythunkpos25;
+  }  if (!yymatchDot(G)) goto l24;  goto l23;
+  l24:;	  G->pos= yypos24; G->thunkpos= yythunkpos24;
+  }  if (!yymatchChar(G, '\'')) goto l17;
+  }
+  l18:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Quoted", G->buf+G->pos));
+  return 1;
+  l17:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Quoted", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlTag(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlTag"));  if (!yymatchChar(G, '<')) goto l26;  if (!yy_Spnl(G)) { goto l26; }
+  {  int yypos27= G->pos, yythunkpos27= G->thunkpos;  if (!yymatchChar(G, '/')) goto l27;  goto l28;
+  l27:;	  G->pos= yypos27; G->thunkpos= yythunkpos27;
+  }
+  l28:;	  if (!yy_AlphanumericAscii(G)) { goto l26; }
+  l29:;	
+  {  int yypos30= G->pos, yythunkpos30= G->thunkpos;  if (!yy_AlphanumericAscii(G)) { goto l30; }  goto l29;
+  l30:;	  G->pos= yypos30; G->thunkpos= yythunkpos30;
+  }  if (!yy_Spnl(G)) { goto l26; }
+  l31:;	
+  {  int yypos32= G->pos, yythunkpos32= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l32; }  goto l31;
+  l32:;	  G->pos= yypos32; G->thunkpos= yythunkpos32;
+  }
+  {  int yypos33= G->pos, yythunkpos33= G->thunkpos;  if (!yymatchChar(G, '/')) goto l33;  goto l34;
+  l33:;	  G->pos= yypos33; G->thunkpos= yythunkpos33;
+  }
+  l34:;	  if (!yy_Spnl(G)) { goto l26; }  if (!yymatchChar(G, '>')) goto l26;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlTag", G->buf+G->pos));
+  return 1;
+  l26:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlTag", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Ticks5(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Ticks5"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l35;  if (!yymatchString(G, "`````")) goto l35;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l35;
+  {  int yypos36= G->pos, yythunkpos36= G->thunkpos;  if (!yymatchChar(G, '`')) goto l36;  goto l35;
+  l36:;	  G->pos= yypos36; G->thunkpos= yythunkpos36;
+  }  yyDo(G, yy_1_Ticks5, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Ticks5", G->buf+G->pos));
+  return 1;
+  l35:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Ticks5", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Ticks4(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Ticks4"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l37;  if (!yymatchString(G, "````")) goto l37;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l37;
+  {  int yypos38= G->pos, yythunkpos38= G->thunkpos;  if (!yymatchChar(G, '`')) goto l38;  goto l37;
+  l38:;	  G->pos= yypos38; G->thunkpos= yythunkpos38;
+  }  yyDo(G, yy_1_Ticks4, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Ticks4", G->buf+G->pos));
+  return 1;
+  l37:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Ticks4", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Ticks3(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Ticks3"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l39;  if (!yymatchString(G, "```")) goto l39;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l39;
+  {  int yypos40= G->pos, yythunkpos40= G->thunkpos;  if (!yymatchChar(G, '`')) goto l40;  goto l39;
+  l40:;	  G->pos= yypos40; G->thunkpos= yythunkpos40;
+  }  yyDo(G, yy_1_Ticks3, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Ticks3", G->buf+G->pos));
+  return 1;
+  l39:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Ticks3", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Ticks2(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Ticks2"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l41;  if (!yymatchString(G, "``")) goto l41;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l41;
+  {  int yypos42= G->pos, yythunkpos42= G->thunkpos;  if (!yymatchChar(G, '`')) goto l42;  goto l41;
+  l42:;	  G->pos= yypos42; G->thunkpos= yythunkpos42;
+  }  yyDo(G, yy_1_Ticks2, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Ticks2", G->buf+G->pos));
+  return 1;
+  l41:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Ticks2", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Ticks1(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Ticks1"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l43;  if (!yymatchChar(G, '`')) goto l43;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l43;
+  {  int yypos44= G->pos, yythunkpos44= G->thunkpos;  if (!yymatchChar(G, '`')) goto l44;  goto l43;
+  l44:;	  G->pos= yypos44; G->thunkpos= yythunkpos44;
+  }  yyDo(G, yy_1_Ticks1, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Ticks1", G->buf+G->pos));
+  return 1;
+  l43:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Ticks1", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SkipBlock(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "SkipBlock"));
+  {  int yypos46= G->pos, yythunkpos46= G->thunkpos;
+  {  int yypos50= G->pos, yythunkpos50= G->thunkpos;  if (!yy_BlankLine(G)) { goto l50; }  goto l47;
+  l50:;	  G->pos= yypos50; G->thunkpos= yythunkpos50;
+  }  if (!yy_RawLine(G)) { goto l47; }
+  l48:;	
+  {  int yypos49= G->pos, yythunkpos49= G->thunkpos;
+  {  int yypos51= G->pos, yythunkpos51= G->thunkpos;  if (!yy_BlankLine(G)) { goto l51; }  goto l49;
+  l51:;	  G->pos= yypos51; G->thunkpos= yythunkpos51;
+  }  if (!yy_RawLine(G)) { goto l49; }  goto l48;
+  l49:;	  G->pos= yypos49; G->thunkpos= yythunkpos49;
+  }
+  l52:;	
+  {  int yypos53= G->pos, yythunkpos53= G->thunkpos;  if (!yy_BlankLine(G)) { goto l53; }  goto l52;
+  l53:;	  G->pos= yypos53; G->thunkpos= yythunkpos53;
+  }  goto l46;
+  l47:;	  G->pos= yypos46; G->thunkpos= yythunkpos46;  if (!yy_BlankLine(G)) { goto l45; }
+  l54:;	
+  {  int yypos55= G->pos, yythunkpos55= G->thunkpos;  if (!yy_BlankLine(G)) { goto l55; }  goto l54;
+  l55:;	  G->pos= yypos55; G->thunkpos= yythunkpos55;
+  }
+  }
+  l46:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "SkipBlock", G->buf+G->pos));
+  return 1;
+  l45:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "SkipBlock", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_References(GREG *G)
+{
+  yyprintf((stderr, "%s\n", "References"));
+  l57:;	
+  {  int yypos58= G->pos, yythunkpos58= G->thunkpos;
+  {  int yypos59= G->pos, yythunkpos59= G->thunkpos;  if (!yy_Reference(G)) { goto l60; }  goto l59;
+  l60:;	  G->pos= yypos59; G->thunkpos= yythunkpos59;  if (!yy_SkipBlock(G)) { goto l58; }
+  }
+  l59:;	  goto l57;
+  l58:;	  G->pos= yypos58; G->thunkpos= yythunkpos58;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "References", G->buf+G->pos));
+  return 1;
+}
+YY_RULE(int) yy_EmptyTitle(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "EmptyTitle"));  if (!yymatchString(G, "")) goto l61;
+  yyprintf((stderr, "  ok   %s @ %s\n", "EmptyTitle", G->buf+G->pos));
+  return 1;
+  l61:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "EmptyTitle", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RefTitleParens(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RefTitleParens"));  if (!yy_Spnl(G)) { goto l62; }  if (!yymatchChar(G, '(')) goto l62;
+  l63:;	
+  {  int yypos64= G->pos, yythunkpos64= G->thunkpos;
+  {  int yypos65= G->pos, yythunkpos65= G->thunkpos;
+  {  int yypos66= G->pos, yythunkpos66= G->thunkpos;  if (!yymatchChar(G, ')')) goto l67;  if (!yy_Sp(G)) { goto l67; }  if (!yy_Newline(G)) { goto l67; }  goto l66;
+  l67:;	  G->pos= yypos66; G->thunkpos= yythunkpos66;  if (!yy_Newline(G)) { goto l65; }
+  }
+  l66:;	  goto l64;
+  l65:;	  G->pos= yypos65; G->thunkpos= yythunkpos65;
+  }  if (!yymatchDot(G)) goto l64;  goto l63;
+  l64:;	  G->pos= yypos64; G->thunkpos= yythunkpos64;
+  }  if (!yymatchChar(G, ')')) goto l62;
+  yyprintf((stderr, "  ok   %s @ %s\n", "RefTitleParens", G->buf+G->pos));
+  return 1;
+  l62:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RefTitleParens", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RefTitleDouble(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RefTitleDouble"));  if (!yy_Spnl(G)) { goto l68; }  if (!yymatchChar(G, '"')) goto l68;
+  l69:;	
+  {  int yypos70= G->pos, yythunkpos70= G->thunkpos;
+  {  int yypos71= G->pos, yythunkpos71= G->thunkpos;
+  {  int yypos72= G->pos, yythunkpos72= G->thunkpos;  if (!yymatchChar(G, '"')) goto l73;  if (!yy_Sp(G)) { goto l73; }  if (!yy_Newline(G)) { goto l73; }  goto l72;
+  l73:;	  G->pos= yypos72; G->thunkpos= yythunkpos72;  if (!yy_Newline(G)) { goto l71; }
+  }
+  l72:;	  goto l70;
+  l71:;	  G->pos= yypos71; G->thunkpos= yythunkpos71;
+  }  if (!yymatchDot(G)) goto l70;  goto l69;
+  l70:;	  G->pos= yypos70; G->thunkpos= yythunkpos70;
+  }  if (!yymatchChar(G, '"')) goto l68;
+  yyprintf((stderr, "  ok   %s @ %s\n", "RefTitleDouble", G->buf+G->pos));
+  return 1;
+  l68:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RefTitleDouble", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RefTitleSingle(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RefTitleSingle"));  if (!yy_Spnl(G)) { goto l74; }  if (!yymatchChar(G, '\'')) goto l74;
+  l75:;	
+  {  int yypos76= G->pos, yythunkpos76= G->thunkpos;
+  {  int yypos77= G->pos, yythunkpos77= G->thunkpos;
+  {  int yypos78= G->pos, yythunkpos78= G->thunkpos;  if (!yymatchChar(G, '\'')) goto l79;  if (!yy_Sp(G)) { goto l79; }  if (!yy_Newline(G)) { goto l79; }  goto l78;
+  l79:;	  G->pos= yypos78; G->thunkpos= yythunkpos78;  if (!yy_Newline(G)) { goto l77; }
+  }
+  l78:;	  goto l76;
+  l77:;	  G->pos= yypos77; G->thunkpos= yythunkpos77;
+  }  if (!yymatchDot(G)) goto l76;  goto l75;
+  l76:;	  G->pos= yypos76; G->thunkpos= yythunkpos76;
+  }  if (!yymatchChar(G, '\'')) goto l74;
+  yyprintf((stderr, "  ok   %s @ %s\n", "RefTitleSingle", G->buf+G->pos));
+  return 1;
+  l74:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RefTitleSingle", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RefTitle(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RefTitle"));
+  {  int yypos81= G->pos, yythunkpos81= G->thunkpos;  if (!yy_RefTitleSingle(G)) { goto l82; }  goto l81;
+  l82:;	  G->pos= yypos81; G->thunkpos= yythunkpos81;  if (!yy_RefTitleDouble(G)) { goto l83; }  goto l81;
+  l83:;	  G->pos= yypos81; G->thunkpos= yythunkpos81;  if (!yy_RefTitleParens(G)) { goto l84; }  goto l81;
+  l84:;	  G->pos= yypos81; G->thunkpos= yythunkpos81;  if (!yy_EmptyTitle(G)) { goto l80; }
+  }
+  l81:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "RefTitle", G->buf+G->pos));
+  return 1;
+  l80:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RefTitle", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RefSrc(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RefSrc"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l85;  if (!yy_Nonspacechar(G)) { goto l85; }
+  l86:;	
+  {  int yypos87= G->pos, yythunkpos87= G->thunkpos;  if (!yy_Nonspacechar(G)) { goto l87; }  goto l86;
+  l87:;	  G->pos= yypos87; G->thunkpos= yythunkpos87;
+  }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l85;  yyDo(G, yy_1_RefSrc, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "RefSrc", G->buf+G->pos));
+  return 1;
+  l85:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RefSrc", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_AutoLinkEmail(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "AutoLinkEmail"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l88;  if (!yy_LocMarker(G)) { goto l88; }  yyDo(G, yySet, -1, 0);  yyDo(G, yy_1_AutoLinkEmail, G->begin, G->end);  if (!yymatchChar(G, '<')) goto l88;
+  {  int yypos89= G->pos, yythunkpos89= G->thunkpos;  if (!yymatchString(G, "mailto:")) goto l89;  goto l90;
+  l89:;	  G->pos= yypos89; G->thunkpos= yythunkpos89;
+  }
+  l90:;	  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l88;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\062\350\377\003\376\377\377\207\376\377\377\107\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l88;
+  l91:;	
+  {  int yypos92= G->pos, yythunkpos92= G->thunkpos;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\062\350\377\003\376\377\377\207\376\377\377\107\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l92;  goto l91;
+  l92:;	  G->pos= yypos92; G->thunkpos= yythunkpos92;
+  }  if (!yymatchChar(G, '@')) goto l88;
+  {  int yypos95= G->pos, yythunkpos95= G->thunkpos;  if (!yy_Newline(G)) { goto l95; }  goto l88;
+  l95:;	  G->pos= yypos95; G->thunkpos= yythunkpos95;
+  }
+  {  int yypos96= G->pos, yythunkpos96= G->thunkpos;  if (!yymatchChar(G, '>')) goto l96;  goto l88;
+  l96:;	  G->pos= yypos96; G->thunkpos= yythunkpos96;
+  }  if (!yymatchDot(G)) goto l88;
+  l93:;	
+  {  int yypos94= G->pos, yythunkpos94= G->thunkpos;
+  {  int yypos97= G->pos, yythunkpos97= G->thunkpos;  if (!yy_Newline(G)) { goto l97; }  goto l94;
+  l97:;	  G->pos= yypos97; G->thunkpos= yythunkpos97;
+  }
+  {  int yypos98= G->pos, yythunkpos98= G->thunkpos;  if (!yymatchChar(G, '>')) goto l98;  goto l94;
+  l98:;	  G->pos= yypos98; G->thunkpos= yythunkpos98;
+  }  if (!yymatchDot(G)) goto l94;  goto l93;
+  l94:;	  G->pos= yypos94; G->thunkpos= yythunkpos94;
+  }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l88;  yyDo(G, yy_2_AutoLinkEmail, G->begin, G->end);  if (!yymatchChar(G, '>')) goto l88;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l88;  yyDo(G, yy_3_AutoLinkEmail, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "AutoLinkEmail", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l88:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "AutoLinkEmail", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_AutoLinkUrl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "AutoLinkUrl"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l99;  if (!yy_LocMarker(G)) { goto l99; }  yyDo(G, yySet, -1, 0);  yyDo(G, yy_1_AutoLinkUrl, G->begin, G->end);  if (!yymatchChar(G, '<')) goto l99;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l99;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\000\000\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l99;
+  l100:;	
+  {  int yypos101= G->pos, yythunkpos101= G->thunkpos;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\000\000\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l101;  goto l100;
+  l101:;	  G->pos= yypos101; G->thunkpos= yythunkpos101;
+  }  if (!yymatchString(G, "://")) goto l99;
+  {  int yypos104= G->pos, yythunkpos104= G->thunkpos;  if (!yy_Newline(G)) { goto l104; }  goto l99;
+  l104:;	  G->pos= yypos104; G->thunkpos= yythunkpos104;
+  }
+  {  int yypos105= G->pos, yythunkpos105= G->thunkpos;  if (!yymatchChar(G, '>')) goto l105;  goto l99;
+  l105:;	  G->pos= yypos105; G->thunkpos= yythunkpos105;
+  }  if (!yymatchDot(G)) goto l99;
+  l102:;	
+  {  int yypos103= G->pos, yythunkpos103= G->thunkpos;
+  {  int yypos106= G->pos, yythunkpos106= G->thunkpos;  if (!yy_Newline(G)) { goto l106; }  goto l103;
+  l106:;	  G->pos= yypos106; G->thunkpos= yythunkpos106;
+  }
+  {  int yypos107= G->pos, yythunkpos107= G->thunkpos;  if (!yymatchChar(G, '>')) goto l107;  goto l103;
+  l107:;	  G->pos= yypos107; G->thunkpos= yythunkpos107;
+  }  if (!yymatchDot(G)) goto l103;  goto l102;
+  l103:;	  G->pos= yypos103; G->thunkpos= yythunkpos103;
+  }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l99;  yyDo(G, yy_2_AutoLinkUrl, G->begin, G->end);  if (!yymatchChar(G, '>')) goto l99;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l99;  yyDo(G, yy_3_AutoLinkUrl, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "AutoLinkUrl", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l99:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "AutoLinkUrl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_TitleDouble(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "TitleDouble"));  if (!yymatchChar(G, '"')) goto l108;
+  l109:;	
+  {  int yypos110= G->pos, yythunkpos110= G->thunkpos;
+  {  int yypos111= G->pos, yythunkpos111= G->thunkpos;  if (!yymatchChar(G, '"')) goto l111;  if (!yy_Sp(G)) { goto l111; }
+  {  int yypos112= G->pos, yythunkpos112= G->thunkpos;  if (!yymatchChar(G, ')')) goto l113;  goto l112;
+  l113:;	  G->pos= yypos112; G->thunkpos= yythunkpos112;  if (!yy_Newline(G)) { goto l111; }
+  }
+  l112:;	  goto l110;
+  l111:;	  G->pos= yypos111; G->thunkpos= yythunkpos111;
+  }  if (!yymatchDot(G)) goto l110;  goto l109;
+  l110:;	  G->pos= yypos110; G->thunkpos= yythunkpos110;
+  }  if (!yymatchChar(G, '"')) goto l108;
+  yyprintf((stderr, "  ok   %s @ %s\n", "TitleDouble", G->buf+G->pos));
+  return 1;
+  l108:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "TitleDouble", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_TitleSingle(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "TitleSingle"));  if (!yymatchChar(G, '\'')) goto l114;
+  l115:;	
+  {  int yypos116= G->pos, yythunkpos116= G->thunkpos;
+  {  int yypos117= G->pos, yythunkpos117= G->thunkpos;  if (!yymatchChar(G, '\'')) goto l117;  if (!yy_Sp(G)) { goto l117; }
+  {  int yypos118= G->pos, yythunkpos118= G->thunkpos;  if (!yymatchChar(G, ')')) goto l119;  goto l118;
+  l119:;	  G->pos= yypos118; G->thunkpos= yythunkpos118;  if (!yy_Newline(G)) { goto l117; }
+  }
+  l118:;	  goto l116;
+  l117:;	  G->pos= yypos117; G->thunkpos= yythunkpos117;
+  }  if (!yymatchDot(G)) goto l116;  goto l115;
+  l116:;	  G->pos= yypos116; G->thunkpos= yythunkpos116;
+  }  if (!yymatchChar(G, '\'')) goto l114;
+  yyprintf((stderr, "  ok   %s @ %s\n", "TitleSingle", G->buf+G->pos));
+  return 1;
+  l114:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "TitleSingle", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Nonspacechar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Nonspacechar"));
+  {  int yypos121= G->pos, yythunkpos121= G->thunkpos;  if (!yy_Spacechar(G)) { goto l121; }  goto l120;
+  l121:;	  G->pos= yypos121; G->thunkpos= yythunkpos121;
+  }
+  {  int yypos122= G->pos, yythunkpos122= G->thunkpos;  if (!yy_Newline(G)) { goto l122; }  goto l120;
+  l122:;	  G->pos= yypos122; G->thunkpos= yythunkpos122;
+  }  if (!yymatchDot(G)) goto l120;
+  yyprintf((stderr, "  ok   %s @ %s\n", "Nonspacechar", G->buf+G->pos));
+  return 1;
+  l120:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Nonspacechar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SourceContents(GREG *G)
+{
+  yyprintf((stderr, "%s\n", "SourceContents"));
+  l124:;	
+  {  int yypos125= G->pos, yythunkpos125= G->thunkpos;
+  {  int yypos126= G->pos, yythunkpos126= G->thunkpos;
+  {  int yypos130= G->pos, yythunkpos130= G->thunkpos;  if (!yymatchChar(G, '(')) goto l130;  goto l127;
+  l130:;	  G->pos= yypos130; G->thunkpos= yythunkpos130;
+  }
+  {  int yypos131= G->pos, yythunkpos131= G->thunkpos;  if (!yymatchChar(G, ')')) goto l131;  goto l127;
+  l131:;	  G->pos= yypos131; G->thunkpos= yythunkpos131;
+  }
+  {  int yypos132= G->pos, yythunkpos132= G->thunkpos;  if (!yymatchChar(G, '>')) goto l132;  goto l127;
+  l132:;	  G->pos= yypos132; G->thunkpos= yythunkpos132;
+  }  if (!yy_Nonspacechar(G)) { goto l127; }
+  l128:;	
+  {  int yypos129= G->pos, yythunkpos129= G->thunkpos;
+  {  int yypos133= G->pos, yythunkpos133= G->thunkpos;  if (!yymatchChar(G, '(')) goto l133;  goto l129;
+  l133:;	  G->pos= yypos133; G->thunkpos= yythunkpos133;
+  }
+  {  int yypos134= G->pos, yythunkpos134= G->thunkpos;  if (!yymatchChar(G, ')')) goto l134;  goto l129;
+  l134:;	  G->pos= yypos134; G->thunkpos= yythunkpos134;
+  }
+  {  int yypos135= G->pos, yythunkpos135= G->thunkpos;  if (!yymatchChar(G, '>')) goto l135;  goto l129;
+  l135:;	  G->pos= yypos135; G->thunkpos= yythunkpos135;
+  }  if (!yy_Nonspacechar(G)) { goto l129; }  goto l128;
+  l129:;	  G->pos= yypos129; G->thunkpos= yythunkpos129;
+  }  goto l126;
+  l127:;	  G->pos= yypos126; G->thunkpos= yythunkpos126;  if (!yymatchChar(G, '(')) goto l125;  if (!yy_SourceContents(G)) { goto l125; }  if (!yymatchChar(G, ')')) goto l125;
+  }
+  l126:;	  goto l124;
+  l125:;	  G->pos= yypos125; G->thunkpos= yythunkpos125;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "SourceContents", G->buf+G->pos));
+  return 1;
+}
+YY_RULE(int) yy_Title(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Title"));
+  {  int yypos137= G->pos, yythunkpos137= G->thunkpos;  if (!yy_TitleSingle(G)) { goto l138; }  goto l137;
+  l138:;	  G->pos= yypos137; G->thunkpos= yythunkpos137;  if (!yy_TitleDouble(G)) { goto l139; }  goto l137;
+  l139:;	  G->pos= yypos137; G->thunkpos= yythunkpos137;  if (!yymatchString(G, "")) goto l136;
+  }
+  l137:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Title", G->buf+G->pos));
+  return 1;
+  l136:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Title", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Source(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Source"));  yyDo(G, yy_1_Source, G->begin, G->end);
+  {  int yypos141= G->pos, yythunkpos141= G->thunkpos;  if (!yymatchChar(G, '<')) goto l142;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l142;  if (!yy_SourceContents(G)) { goto l142; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l142;  yyDo(G, yy_2_Source, G->begin, G->end);  if (!yymatchChar(G, '>')) goto l142;  goto l141;
+  l142:;	  G->pos= yypos141; G->thunkpos= yythunkpos141;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l140;  if (!yy_SourceContents(G)) { goto l140; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l140;  yyDo(G, yy_3_Source, G->begin, G->end);
+  }
+  l141:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Source", G->buf+G->pos));
+  return 1;
+  l140:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Source", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Label(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "Label"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l143;  if (!yy_LocMarker(G)) { goto l143; }  yyDo(G, yySet, -1, 0);  if (!yymatchChar(G, '[')) goto l143;
+  {  int yypos144= G->pos, yythunkpos144= G->thunkpos;
+  {  int yypos146= G->pos, yythunkpos146= G->thunkpos;  if (!yymatchChar(G, '^')) goto l146;  goto l145;
+  l146:;	  G->pos= yypos146; G->thunkpos= yythunkpos146;
+  }  yyText(G, G->begin, G->end);  if (!( EXT(pmh_EXT_NOTES) )) goto l145;  goto l144;
+  l145:;	  G->pos= yypos144; G->thunkpos= yythunkpos144;
+  {  int yypos147= G->pos, yythunkpos147= G->thunkpos;  if (!yymatchDot(G)) goto l143;  G->pos= yypos147; G->thunkpos= yythunkpos147;
+  }  yyText(G, G->begin, G->end);  if (!( !EXT(pmh_EXT_NOTES) )) goto l143;
+  }
+  l144:;	  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l143;
+  l148:;	
+  {  int yypos149= G->pos, yythunkpos149= G->thunkpos;
+  {  int yypos150= G->pos, yythunkpos150= G->thunkpos;  if (!yymatchChar(G, ']')) goto l150;  goto l149;
+  l150:;	  G->pos= yypos150; G->thunkpos= yythunkpos150;
+  }  if (!yy_Inline(G)) { goto l149; }  goto l148;
+  l149:;	  G->pos= yypos149; G->thunkpos= yythunkpos149;
+  }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l143;  yyDo(G, yy_1_Label, G->begin, G->end);  if (!yymatchChar(G, ']')) goto l143;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l143;  yyDo(G, yy_2_Label, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Label", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l143:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Label", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ReferenceLinkSingle(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "ReferenceLinkSingle"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l151;  if (!yy_Label(G)) { goto l151; }  yyDo(G, yySet, -1, 0);
+  {  int yypos152= G->pos, yythunkpos152= G->thunkpos;  if (!yy_Spnl(G)) { goto l152; }  if (!yymatchString(G, "[]")) goto l152;  goto l153;
+  l152:;	  G->pos= yypos152; G->thunkpos= yythunkpos152;
+  }
+  l153:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l151;  yyDo(G, yy_1_ReferenceLinkSingle, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ReferenceLinkSingle", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l151:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ReferenceLinkSingle", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ReferenceLinkDouble(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 2, 0);
+  yyprintf((stderr, "%s\n", "ReferenceLinkDouble"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l154;  if (!yy_Label(G)) { goto l154; }  yyDo(G, yySet, -2, 0);  if (!yy_Spnl(G)) { goto l154; }
+  {  int yypos155= G->pos, yythunkpos155= G->thunkpos;  if (!yymatchString(G, "[]")) goto l155;  goto l154;
+  l155:;	  G->pos= yypos155; G->thunkpos= yythunkpos155;
+  }  if (!yy_Label(G)) { goto l154; }  yyDo(G, yySet, -1, 0);  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l154;  yyDo(G, yy_1_ReferenceLinkDouble, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ReferenceLinkDouble", G->buf+G->pos));  yyDo(G, yyPop, 2, 0);
+  return 1;
+  l154:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ReferenceLinkDouble", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_AutoLink(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "AutoLink"));
+  {  int yypos157= G->pos, yythunkpos157= G->thunkpos;  if (!yy_AutoLinkUrl(G)) { goto l158; }  goto l157;
+  l158:;	  G->pos= yypos157; G->thunkpos= yythunkpos157;  if (!yy_AutoLinkEmail(G)) { goto l156; }
+  }
+  l157:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "AutoLink", G->buf+G->pos));
+  return 1;
+  l156:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "AutoLink", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ReferenceLink(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "ReferenceLink"));
+  {  int yypos160= G->pos, yythunkpos160= G->thunkpos;  if (!yy_ReferenceLinkDouble(G)) { goto l161; }  goto l160;
+  l161:;	  G->pos= yypos160; G->thunkpos= yythunkpos160;  if (!yy_ReferenceLinkSingle(G)) { goto l159; }
+  }
+  l160:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "ReferenceLink", G->buf+G->pos));
+  return 1;
+  l159:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ReferenceLink", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ExplicitLink(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 2, 0);
+  yyprintf((stderr, "%s\n", "ExplicitLink"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l162;  if (!yy_Label(G)) { goto l162; }  yyDo(G, yySet, -2, 0);  if (!yy_Spnl(G)) { goto l162; }  if (!yymatchChar(G, '(')) goto l162;  if (!yy_Sp(G)) { goto l162; }  if (!yy_Source(G)) { goto l162; }  yyDo(G, yySet, -1, 0);  if (!yy_Spnl(G)) { goto l162; }  if (!yy_Title(G)) { goto l162; }  if (!yy_Sp(G)) { goto l162; }  if (!yymatchChar(G, ')')) goto l162;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l162;  yyDo(G, yy_1_ExplicitLink, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ExplicitLink", G->buf+G->pos));  yyDo(G, yyPop, 2, 0);
+  return 1;
+  l162:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ExplicitLink", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_StrongUl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "StrongUl"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l163;  if (!yy_LocMarker(G)) { goto l163; }  yyDo(G, yySet, -1, 0);  if (!yymatchString(G, "__")) goto l163;
+  {  int yypos164= G->pos, yythunkpos164= G->thunkpos;  if (!yy_Whitespace(G)) { goto l164; }  goto l163;
+  l164:;	  G->pos= yypos164; G->thunkpos= yythunkpos164;
+  }
+  {  int yypos167= G->pos, yythunkpos167= G->thunkpos;  if (!yymatchString(G, "__")) goto l167;  goto l163;
+  l167:;	  G->pos= yypos167; G->thunkpos= yythunkpos167;
+  }  if (!yy_Inline(G)) { goto l163; }
+  l165:;	
+  {  int yypos166= G->pos, yythunkpos166= G->thunkpos;
+  {  int yypos168= G->pos, yythunkpos168= G->thunkpos;  if (!yymatchString(G, "__")) goto l168;  goto l166;
+  l168:;	  G->pos= yypos168; G->thunkpos= yythunkpos168;
+  }  if (!yy_Inline(G)) { goto l166; }  goto l165;
+  l166:;	  G->pos= yypos166; G->thunkpos= yythunkpos166;
+  }  if (!yymatchString(G, "__")) goto l163;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l163;  yyDo(G, yy_1_StrongUl, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "StrongUl", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l163:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "StrongUl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_StrongStar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "StrongStar"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l169;  if (!yy_LocMarker(G)) { goto l169; }  yyDo(G, yySet, -1, 0);  if (!yymatchString(G, "**")) goto l169;
+  {  int yypos170= G->pos, yythunkpos170= G->thunkpos;  if (!yy_Whitespace(G)) { goto l170; }  goto l169;
+  l170:;	  G->pos= yypos170; G->thunkpos= yythunkpos170;
+  }
+  {  int yypos173= G->pos, yythunkpos173= G->thunkpos;  if (!yymatchString(G, "**")) goto l173;  goto l169;
+  l173:;	  G->pos= yypos173; G->thunkpos= yythunkpos173;
+  }  if (!yy_Inline(G)) { goto l169; }
+  l171:;	
+  {  int yypos172= G->pos, yythunkpos172= G->thunkpos;
+  {  int yypos174= G->pos, yythunkpos174= G->thunkpos;  if (!yymatchString(G, "**")) goto l174;  goto l172;
+  l174:;	  G->pos= yypos174; G->thunkpos= yythunkpos174;
+  }  if (!yy_Inline(G)) { goto l172; }  goto l171;
+  l172:;	  G->pos= yypos172; G->thunkpos= yythunkpos172;
+  }  if (!yymatchString(G, "**")) goto l169;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l169;  yyDo(G, yy_1_StrongStar, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "StrongStar", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l169:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "StrongStar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Whitespace(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Whitespace"));
+  {  int yypos176= G->pos, yythunkpos176= G->thunkpos;  if (!yy_Spacechar(G)) { goto l177; }  goto l176;
+  l177:;	  G->pos= yypos176; G->thunkpos= yythunkpos176;  if (!yy_Newline(G)) { goto l175; }
+  }
+  l176:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Whitespace", G->buf+G->pos));
+  return 1;
+  l175:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Whitespace", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_EmphUl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "EmphUl"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l178;  if (!yy_LocMarker(G)) { goto l178; }  yyDo(G, yySet, -1, 0);  if (!yymatchChar(G, '_')) goto l178;
+  {  int yypos179= G->pos, yythunkpos179= G->thunkpos;  if (!yy_Whitespace(G)) { goto l179; }  goto l178;
+  l179:;	  G->pos= yypos179; G->thunkpos= yythunkpos179;
+  }
+  {  int yypos182= G->pos, yythunkpos182= G->thunkpos;
+  {  int yypos184= G->pos, yythunkpos184= G->thunkpos;  if (!yymatchChar(G, '_')) goto l184;  goto l183;
+  l184:;	  G->pos= yypos184; G->thunkpos= yythunkpos184;
+  }  if (!yy_Inline(G)) { goto l183; }  goto l182;
+  l183:;	  G->pos= yypos182; G->thunkpos= yythunkpos182;  if (!yy_StrongUl(G)) { goto l178; }
+  }
+  l182:;	
+  l180:;	
+  {  int yypos181= G->pos, yythunkpos181= G->thunkpos;
+  {  int yypos185= G->pos, yythunkpos185= G->thunkpos;
+  {  int yypos187= G->pos, yythunkpos187= G->thunkpos;  if (!yymatchChar(G, '_')) goto l187;  goto l186;
+  l187:;	  G->pos= yypos187; G->thunkpos= yythunkpos187;
+  }  if (!yy_Inline(G)) { goto l186; }  goto l185;
+  l186:;	  G->pos= yypos185; G->thunkpos= yythunkpos185;  if (!yy_StrongUl(G)) { goto l181; }
+  }
+  l185:;	  goto l180;
+  l181:;	  G->pos= yypos181; G->thunkpos= yythunkpos181;
+  }  if (!yymatchChar(G, '_')) goto l178;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l178;  yyDo(G, yy_1_EmphUl, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "EmphUl", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l178:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "EmphUl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_EmphStar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "EmphStar"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l188;  if (!yy_LocMarker(G)) { goto l188; }  yyDo(G, yySet, -1, 0);  if (!yymatchChar(G, '*')) goto l188;
+  {  int yypos189= G->pos, yythunkpos189= G->thunkpos;  if (!yy_Whitespace(G)) { goto l189; }  goto l188;
+  l189:;	  G->pos= yypos189; G->thunkpos= yythunkpos189;
+  }
+  {  int yypos192= G->pos, yythunkpos192= G->thunkpos;
+  {  int yypos194= G->pos, yythunkpos194= G->thunkpos;  if (!yymatchChar(G, '*')) goto l194;  goto l193;
+  l194:;	  G->pos= yypos194; G->thunkpos= yythunkpos194;
+  }  if (!yy_Inline(G)) { goto l193; }  goto l192;
+  l193:;	  G->pos= yypos192; G->thunkpos= yythunkpos192;  if (!yy_StrongStar(G)) { goto l188; }
+  }
+  l192:;	
+  l190:;	
+  {  int yypos191= G->pos, yythunkpos191= G->thunkpos;
+  {  int yypos195= G->pos, yythunkpos195= G->thunkpos;
+  {  int yypos197= G->pos, yythunkpos197= G->thunkpos;  if (!yymatchChar(G, '*')) goto l197;  goto l196;
+  l197:;	  G->pos= yypos197; G->thunkpos= yythunkpos197;
+  }  if (!yy_Inline(G)) { goto l196; }  goto l195;
+  l196:;	  G->pos= yypos195; G->thunkpos= yythunkpos195;  if (!yy_StrongStar(G)) { goto l191; }
+  }
+  l195:;	  goto l190;
+  l191:;	  G->pos= yypos191; G->thunkpos= yythunkpos191;
+  }  if (!yymatchChar(G, '*')) goto l188;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l188;  yyDo(G, yy_1_EmphStar, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "EmphStar", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l188:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "EmphStar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_StarLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "StarLine"));
+  {  int yypos199= G->pos, yythunkpos199= G->thunkpos;  if (!yymatchString(G, "****")) goto l200;
+  l201:;	
+  {  int yypos202= G->pos, yythunkpos202= G->thunkpos;  if (!yymatchChar(G, '*')) goto l202;  goto l201;
+  l202:;	  G->pos= yypos202; G->thunkpos= yythunkpos202;
+  }  goto l199;
+  l200:;	  G->pos= yypos199; G->thunkpos= yythunkpos199;  if (!yy_Spacechar(G)) { goto l198; }  if (!yymatchChar(G, '*')) goto l198;
+  l203:;	
+  {  int yypos204= G->pos, yythunkpos204= G->thunkpos;  if (!yymatchChar(G, '*')) goto l204;  goto l203;
+  l204:;	  G->pos= yypos204; G->thunkpos= yythunkpos204;
+  }
+  {  int yypos205= G->pos, yythunkpos205= G->thunkpos;  if (!yy_Spacechar(G)) { goto l198; }  G->pos= yypos205; G->thunkpos= yythunkpos205;
+  }
+  }
+  l199:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "StarLine", G->buf+G->pos));
+  return 1;
+  l198:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "StarLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_UlLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "UlLine"));
+  {  int yypos207= G->pos, yythunkpos207= G->thunkpos;  if (!yymatchString(G, "____")) goto l208;
+  l209:;	
+  {  int yypos210= G->pos, yythunkpos210= G->thunkpos;  if (!yymatchChar(G, '_')) goto l210;  goto l209;
+  l210:;	  G->pos= yypos210; G->thunkpos= yythunkpos210;
+  }  goto l207;
+  l208:;	  G->pos= yypos207; G->thunkpos= yythunkpos207;  if (!yy_Spacechar(G)) { goto l206; }  if (!yymatchChar(G, '_')) goto l206;
+  l211:;	
+  {  int yypos212= G->pos, yythunkpos212= G->thunkpos;  if (!yymatchChar(G, '_')) goto l212;  goto l211;
+  l212:;	  G->pos= yypos212; G->thunkpos= yythunkpos212;
+  }
+  {  int yypos213= G->pos, yythunkpos213= G->thunkpos;  if (!yy_Spacechar(G)) { goto l206; }  G->pos= yypos213; G->thunkpos= yythunkpos213;
+  }
+  }
+  l207:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "UlLine", G->buf+G->pos));
+  return 1;
+  l206:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "UlLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SpecialChar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "SpecialChar"));
+  {  int yypos215= G->pos, yythunkpos215= G->thunkpos;  if (!yymatchChar(G, '~')) goto l216;  goto l215;
+  l216:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '*')) goto l217;  goto l215;
+  l217:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '_')) goto l218;  goto l215;
+  l218:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '`')) goto l219;  goto l215;
+  l219:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '&')) goto l220;  goto l215;
+  l220:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '[')) goto l221;  goto l215;
+  l221:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, ']')) goto l222;  goto l215;
+  l222:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '(')) goto l223;  goto l215;
+  l223:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, ')')) goto l224;  goto l215;
+  l224:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '<')) goto l225;  goto l215;
+  l225:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '!')) goto l226;  goto l215;
+  l226:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '#')) goto l227;  goto l215;
+  l227:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '\\')) goto l228;  goto l215;
+  l228:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '\'')) goto l229;  goto l215;
+  l229:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yymatchChar(G, '"')) goto l230;  goto l215;
+  l230:;	  G->pos= yypos215; G->thunkpos= yythunkpos215;  if (!yy_ExtendedSpecialChar(G)) { goto l214; }
+  }
+  l215:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "SpecialChar", G->buf+G->pos));
+  return 1;
+  l214:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "SpecialChar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Eof(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Eof"));
+  {  int yypos232= G->pos, yythunkpos232= G->thunkpos;  if (!yymatchDot(G)) goto l232;  goto l231;
+  l232:;	  G->pos= yypos232; G->thunkpos= yythunkpos232;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Eof", G->buf+G->pos));
+  return 1;
+  l231:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Eof", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_NormalEndline(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "NormalEndline"));  if (!yy_Sp(G)) { goto l233; }  if (!yy_Newline(G)) { goto l233; }
+  {  int yypos234= G->pos, yythunkpos234= G->thunkpos;  if (!yy_BlankLine(G)) { goto l234; }  goto l233;
+  l234:;	  G->pos= yypos234; G->thunkpos= yythunkpos234;
+  }
+  {  int yypos235= G->pos, yythunkpos235= G->thunkpos;  if (!yymatchChar(G, '>')) goto l235;  goto l233;
+  l235:;	  G->pos= yypos235; G->thunkpos= yythunkpos235;
+  }
+  {  int yypos236= G->pos, yythunkpos236= G->thunkpos;  if (!yy_AtxStart(G)) { goto l236; }  goto l233;
+  l236:;	  G->pos= yypos236; G->thunkpos= yythunkpos236;
+  }
+  {  int yypos237= G->pos, yythunkpos237= G->thunkpos;  if (!yy_Line(G)) { goto l237; }
+  {  int yypos238= G->pos, yythunkpos238= G->thunkpos;  if (!yymatchChar(G, '=')) goto l239;
+  l240:;	
+  {  int yypos241= G->pos, yythunkpos241= G->thunkpos;  if (!yymatchChar(G, '=')) goto l241;  goto l240;
+  l241:;	  G->pos= yypos241; G->thunkpos= yythunkpos241;
+  }  goto l238;
+  l239:;	  G->pos= yypos238; G->thunkpos= yythunkpos238;  if (!yymatchChar(G, '-')) goto l237;
+  l242:;	
+  {  int yypos243= G->pos, yythunkpos243= G->thunkpos;  if (!yymatchChar(G, '-')) goto l243;  goto l242;
+  l243:;	  G->pos= yypos243; G->thunkpos= yythunkpos243;
+  }
+  }
+  l238:;	  if (!yy_Newline(G)) { goto l237; }  goto l233;
+  l237:;	  G->pos= yypos237; G->thunkpos= yythunkpos237;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "NormalEndline", G->buf+G->pos));
+  return 1;
+  l233:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "NormalEndline", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_TerminalEndline(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "TerminalEndline"));  if (!yy_Sp(G)) { goto l244; }  if (!yy_Newline(G)) { goto l244; }  if (!yy_Eof(G)) { goto l244; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "TerminalEndline", G->buf+G->pos));
+  return 1;
+  l244:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "TerminalEndline", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_LineBreak(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "LineBreak"));  if (!yymatchString(G, "  ")) goto l245;  if (!yy_NormalEndline(G)) { goto l245; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "LineBreak", G->buf+G->pos));
+  return 1;
+  l245:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "LineBreak", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_CharEntity(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "CharEntity"));  if (!yymatchChar(G, '&')) goto l246;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l246;
+  l247:;	
+  {  int yypos248= G->pos, yythunkpos248= G->thunkpos;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l248;  goto l247;
+  l248:;	  G->pos= yypos248; G->thunkpos= yythunkpos248;
+  }  if (!yymatchChar(G, ';')) goto l246;
+  yyprintf((stderr, "  ok   %s @ %s\n", "CharEntity", G->buf+G->pos));
+  return 1;
+  l246:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "CharEntity", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_DecEntity(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "DecEntity"));  if (!yymatchChar(G, '&')) goto l249;  if (!yymatchChar(G, '#')) goto l249;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l249;
+  l250:;	
+  {  int yypos251= G->pos, yythunkpos251= G->thunkpos;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l251;  goto l250;
+  l251:;	  G->pos= yypos251; G->thunkpos= yythunkpos251;
+  }  if (!yymatchChar(G, ';')) goto l249;
+  yyprintf((stderr, "  ok   %s @ %s\n", "DecEntity", G->buf+G->pos));
+  return 1;
+  l249:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "DecEntity", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HexEntity(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HexEntity"));  if (!yymatchChar(G, '&')) goto l252;  if (!yymatchChar(G, '#')) goto l252;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l252;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\176\000\000\000\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l252;
+  l253:;	
+  {  int yypos254= G->pos, yythunkpos254= G->thunkpos;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\176\000\000\000\176\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l254;  goto l253;
+  l254:;	  G->pos= yypos254; G->thunkpos= yythunkpos254;
+  }  if (!yymatchChar(G, ';')) goto l252;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HexEntity", G->buf+G->pos));
+  return 1;
+  l252:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HexEntity", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Alphanumeric(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Alphanumeric"));
+  {  int yypos256= G->pos, yythunkpos256= G->thunkpos;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l257;  goto l256;
+  l257:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\200")) goto l258;  goto l256;
+  l258:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\201")) goto l259;  goto l256;
+  l259:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\202")) goto l260;  goto l256;
+  l260:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\203")) goto l261;  goto l256;
+  l261:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\204")) goto l262;  goto l256;
+  l262:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\205")) goto l263;  goto l256;
+  l263:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\206")) goto l264;  goto l256;
+  l264:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\207")) goto l265;  goto l256;
+  l265:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\210")) goto l266;  goto l256;
+  l266:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\211")) goto l267;  goto l256;
+  l267:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\212")) goto l268;  goto l256;
+  l268:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\213")) goto l269;  goto l256;
+  l269:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\214")) goto l270;  goto l256;
+  l270:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\215")) goto l271;  goto l256;
+  l271:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\216")) goto l272;  goto l256;
+  l272:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\217")) goto l273;  goto l256;
+  l273:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\220")) goto l274;  goto l256;
+  l274:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\221")) goto l275;  goto l256;
+  l275:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\222")) goto l276;  goto l256;
+  l276:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\223")) goto l277;  goto l256;
+  l277:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\224")) goto l278;  goto l256;
+  l278:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\225")) goto l279;  goto l256;
+  l279:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\226")) goto l280;  goto l256;
+  l280:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\227")) goto l281;  goto l256;
+  l281:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\230")) goto l282;  goto l256;
+  l282:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\231")) goto l283;  goto l256;
+  l283:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\232")) goto l284;  goto l256;
+  l284:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\233")) goto l285;  goto l256;
+  l285:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\234")) goto l286;  goto l256;
+  l286:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\235")) goto l287;  goto l256;
+  l287:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\236")) goto l288;  goto l256;
+  l288:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\237")) goto l289;  goto l256;
+  l289:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\240")) goto l290;  goto l256;
+  l290:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\241")) goto l291;  goto l256;
+  l291:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\242")) goto l292;  goto l256;
+  l292:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\243")) goto l293;  goto l256;
+  l293:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\244")) goto l294;  goto l256;
+  l294:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\245")) goto l295;  goto l256;
+  l295:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\246")) goto l296;  goto l256;
+  l296:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\247")) goto l297;  goto l256;
+  l297:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\250")) goto l298;  goto l256;
+  l298:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\251")) goto l299;  goto l256;
+  l299:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\252")) goto l300;  goto l256;
+  l300:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\253")) goto l301;  goto l256;
+  l301:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\254")) goto l302;  goto l256;
+  l302:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\255")) goto l303;  goto l256;
+  l303:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\256")) goto l304;  goto l256;
+  l304:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\257")) goto l305;  goto l256;
+  l305:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\260")) goto l306;  goto l256;
+  l306:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\261")) goto l307;  goto l256;
+  l307:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\262")) goto l308;  goto l256;
+  l308:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\263")) goto l309;  goto l256;
+  l309:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\264")) goto l310;  goto l256;
+  l310:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\265")) goto l311;  goto l256;
+  l311:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\266")) goto l312;  goto l256;
+  l312:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\267")) goto l313;  goto l256;
+  l313:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\270")) goto l314;  goto l256;
+  l314:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\271")) goto l315;  goto l256;
+  l315:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\272")) goto l316;  goto l256;
+  l316:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\273")) goto l317;  goto l256;
+  l317:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\274")) goto l318;  goto l256;
+  l318:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\275")) goto l319;  goto l256;
+  l319:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\276")) goto l320;  goto l256;
+  l320:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\277")) goto l321;  goto l256;
+  l321:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\300")) goto l322;  goto l256;
+  l322:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\301")) goto l323;  goto l256;
+  l323:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\302")) goto l324;  goto l256;
+  l324:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\303")) goto l325;  goto l256;
+  l325:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\304")) goto l326;  goto l256;
+  l326:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\305")) goto l327;  goto l256;
+  l327:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\306")) goto l328;  goto l256;
+  l328:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\307")) goto l329;  goto l256;
+  l329:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\310")) goto l330;  goto l256;
+  l330:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\311")) goto l331;  goto l256;
+  l331:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\312")) goto l332;  goto l256;
+  l332:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\313")) goto l333;  goto l256;
+  l333:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\314")) goto l334;  goto l256;
+  l334:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\315")) goto l335;  goto l256;
+  l335:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\316")) goto l336;  goto l256;
+  l336:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\317")) goto l337;  goto l256;
+  l337:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\320")) goto l338;  goto l256;
+  l338:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\321")) goto l339;  goto l256;
+  l339:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\322")) goto l340;  goto l256;
+  l340:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\323")) goto l341;  goto l256;
+  l341:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\324")) goto l342;  goto l256;
+  l342:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\325")) goto l343;  goto l256;
+  l343:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\326")) goto l344;  goto l256;
+  l344:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\327")) goto l345;  goto l256;
+  l345:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\330")) goto l346;  goto l256;
+  l346:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\331")) goto l347;  goto l256;
+  l347:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\332")) goto l348;  goto l256;
+  l348:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\333")) goto l349;  goto l256;
+  l349:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\334")) goto l350;  goto l256;
+  l350:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\335")) goto l351;  goto l256;
+  l351:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\336")) goto l352;  goto l256;
+  l352:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\337")) goto l353;  goto l256;
+  l353:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\340")) goto l354;  goto l256;
+  l354:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\341")) goto l355;  goto l256;
+  l355:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\342")) goto l356;  goto l256;
+  l356:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\343")) goto l357;  goto l256;
+  l357:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\344")) goto l358;  goto l256;
+  l358:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\345")) goto l359;  goto l256;
+  l359:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\346")) goto l360;  goto l256;
+  l360:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\347")) goto l361;  goto l256;
+  l361:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\350")) goto l362;  goto l256;
+  l362:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\351")) goto l363;  goto l256;
+  l363:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\352")) goto l364;  goto l256;
+  l364:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\353")) goto l365;  goto l256;
+  l365:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\354")) goto l366;  goto l256;
+  l366:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\355")) goto l367;  goto l256;
+  l367:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\356")) goto l368;  goto l256;
+  l368:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\357")) goto l369;  goto l256;
+  l369:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\360")) goto l370;  goto l256;
+  l370:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\361")) goto l371;  goto l256;
+  l371:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\362")) goto l372;  goto l256;
+  l372:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\363")) goto l373;  goto l256;
+  l373:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\364")) goto l374;  goto l256;
+  l374:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\365")) goto l375;  goto l256;
+  l375:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\366")) goto l376;  goto l256;
+  l376:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\367")) goto l377;  goto l256;
+  l377:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\370")) goto l378;  goto l256;
+  l378:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\371")) goto l379;  goto l256;
+  l379:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\372")) goto l380;  goto l256;
+  l380:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\373")) goto l381;  goto l256;
+  l381:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\374")) goto l382;  goto l256;
+  l382:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\375")) goto l383;  goto l256;
+  l383:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\376")) goto l384;  goto l256;
+  l384:;	  G->pos= yypos256; G->thunkpos= yythunkpos256;  if (!yymatchString(G, "\377")) goto l255;
+  }
+  l256:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Alphanumeric", G->buf+G->pos));
+  return 1;
+  l255:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Alphanumeric", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_NormalChar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "NormalChar"));
+  {  int yypos386= G->pos, yythunkpos386= G->thunkpos;
+  {  int yypos387= G->pos, yythunkpos387= G->thunkpos;  if (!yy_SpecialChar(G)) { goto l388; }  goto l387;
+  l388:;	  G->pos= yypos387; G->thunkpos= yythunkpos387;  if (!yy_Spacechar(G)) { goto l389; }  goto l387;
+  l389:;	  G->pos= yypos387; G->thunkpos= yythunkpos387;  if (!yy_Newline(G)) { goto l386; }
+  }
+  l387:;	  goto l385;
+  l386:;	  G->pos= yypos386; G->thunkpos= yythunkpos386;
+  }  if (!yymatchDot(G)) goto l385;
+  yyprintf((stderr, "  ok   %s @ %s\n", "NormalChar", G->buf+G->pos));
+  return 1;
+  l385:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "NormalChar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Symbol(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Symbol"));  if (!yy_SpecialChar(G)) { goto l390; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Symbol", G->buf+G->pos));
+  return 1;
+  l390:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Symbol", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_EscapedChar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "EscapedChar"));  if (!yymatchChar(G, '\\')) goto l391;
+  {  int yypos392= G->pos, yythunkpos392= G->thunkpos;  if (!yy_Newline(G)) { goto l392; }  goto l391;
+  l392:;	  G->pos= yypos392; G->thunkpos= yythunkpos392;
+  }  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\012\157\000\120\000\000\000\270\001\000\000\070\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l391;
+  yyprintf((stderr, "  ok   %s @ %s\n", "EscapedChar", G->buf+G->pos));
+  return 1;
+  l391:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "EscapedChar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Entity(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "Entity"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l393;  if (!yy_LocMarker(G)) { goto l393; }  yyDo(G, yySet, -1, 0);
+  {  int yypos394= G->pos, yythunkpos394= G->thunkpos;  if (!yy_HexEntity(G)) { goto l395; }  goto l394;
+  l395:;	  G->pos= yypos394; G->thunkpos= yythunkpos394;  if (!yy_DecEntity(G)) { goto l396; }  goto l394;
+  l396:;	  G->pos= yypos394; G->thunkpos= yythunkpos394;  if (!yy_CharEntity(G)) { goto l393; }
+  }
+  l394:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l393;  yyDo(G, yy_1_Entity, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Entity", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l393:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Entity", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RawHtml(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "RawHtml"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l397;  if (!yy_LocMarker(G)) { goto l397; }  yyDo(G, yySet, -1, 0);
+  {  int yypos398= G->pos, yythunkpos398= G->thunkpos;  if (!yy_HtmlComment(G)) { goto l399; }  goto l398;
+  l399:;	  G->pos= yypos398; G->thunkpos= yythunkpos398;  if (!yy_HtmlBlockScript(G)) { goto l400; }  goto l398;
+  l400:;	  G->pos= yypos398; G->thunkpos= yythunkpos398;  if (!yy_HtmlTag(G)) { goto l397; }
+  }
+  l398:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l397;  yyDo(G, yy_1_RawHtml, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "RawHtml", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l397:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RawHtml", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Code(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "Code"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l401;
+  {  int yypos402= G->pos, yythunkpos402= G->thunkpos;  if (!yy_Ticks1(G)) { goto l403; }  yyDo(G, yySet, -1, 0);  if (!yy_Sp(G)) { goto l403; }
+  {  int yypos406= G->pos, yythunkpos406= G->thunkpos;
+  {  int yypos410= G->pos, yythunkpos410= G->thunkpos;  if (!yymatchChar(G, '`')) goto l410;  goto l407;
+  l410:;	  G->pos= yypos410; G->thunkpos= yythunkpos410;
+  }  if (!yy_Nonspacechar(G)) { goto l407; }
+  l408:;	
+  {  int yypos409= G->pos, yythunkpos409= G->thunkpos;
+  {  int yypos411= G->pos, yythunkpos411= G->thunkpos;  if (!yymatchChar(G, '`')) goto l411;  goto l409;
+  l411:;	  G->pos= yypos411; G->thunkpos= yythunkpos411;
+  }  if (!yy_Nonspacechar(G)) { goto l409; }  goto l408;
+  l409:;	  G->pos= yypos409; G->thunkpos= yythunkpos409;
+  }  goto l406;
+  l407:;	  G->pos= yypos406; G->thunkpos= yythunkpos406;
+  {  int yypos413= G->pos, yythunkpos413= G->thunkpos;  if (!yy_Ticks1(G)) { goto l413; }  goto l412;
+  l413:;	  G->pos= yypos413; G->thunkpos= yythunkpos413;
+  }  if (!yymatchChar(G, '`')) goto l412;
+  l414:;	
+  {  int yypos415= G->pos, yythunkpos415= G->thunkpos;  if (!yymatchChar(G, '`')) goto l415;  goto l414;
+  l415:;	  G->pos= yypos415; G->thunkpos= yythunkpos415;
+  }  goto l406;
+  l412:;	  G->pos= yypos406; G->thunkpos= yythunkpos406;
+  {  int yypos416= G->pos, yythunkpos416= G->thunkpos;  if (!yy_Sp(G)) { goto l416; }  if (!yy_Ticks1(G)) { goto l416; }  goto l403;
+  l416:;	  G->pos= yypos416; G->thunkpos= yythunkpos416;
+  }
+  {  int yypos417= G->pos, yythunkpos417= G->thunkpos;  if (!yy_Spacechar(G)) { goto l418; }  goto l417;
+  l418:;	  G->pos= yypos417; G->thunkpos= yythunkpos417;  if (!yy_Newline(G)) { goto l403; }
+  {  int yypos419= G->pos, yythunkpos419= G->thunkpos;  if (!yy_BlankLine(G)) { goto l419; }  goto l403;
+  l419:;	  G->pos= yypos419; G->thunkpos= yythunkpos419;
+  }
+  }
+  l417:;	
+  }
+  l406:;	
+  l404:;	
+  {  int yypos405= G->pos, yythunkpos405= G->thunkpos;
+  {  int yypos420= G->pos, yythunkpos420= G->thunkpos;
+  {  int yypos424= G->pos, yythunkpos424= G->thunkpos;  if (!yymatchChar(G, '`')) goto l424;  goto l421;
+  l424:;	  G->pos= yypos424; G->thunkpos= yythunkpos424;
+  }  if (!yy_Nonspacechar(G)) { goto l421; }
+  l422:;	
+  {  int yypos423= G->pos, yythunkpos423= G->thunkpos;
+  {  int yypos425= G->pos, yythunkpos425= G->thunkpos;  if (!yymatchChar(G, '`')) goto l425;  goto l423;
+  l425:;	  G->pos= yypos425; G->thunkpos= yythunkpos425;
+  }  if (!yy_Nonspacechar(G)) { goto l423; }  goto l422;
+  l423:;	  G->pos= yypos423; G->thunkpos= yythunkpos423;
+  }  goto l420;
+  l421:;	  G->pos= yypos420; G->thunkpos= yythunkpos420;
+  {  int yypos427= G->pos, yythunkpos427= G->thunkpos;  if (!yy_Ticks1(G)) { goto l427; }  goto l426;
+  l427:;	  G->pos= yypos427; G->thunkpos= yythunkpos427;
+  }  if (!yymatchChar(G, '`')) goto l426;
+  l428:;	
+  {  int yypos429= G->pos, yythunkpos429= G->thunkpos;  if (!yymatchChar(G, '`')) goto l429;  goto l428;
+  l429:;	  G->pos= yypos429; G->thunkpos= yythunkpos429;
+  }  goto l420;
+  l426:;	  G->pos= yypos420; G->thunkpos= yythunkpos420;
+  {  int yypos430= G->pos, yythunkpos430= G->thunkpos;  if (!yy_Sp(G)) { goto l430; }  if (!yy_Ticks1(G)) { goto l430; }  goto l405;
+  l430:;	  G->pos= yypos430; G->thunkpos= yythunkpos430;
+  }
+  {  int yypos431= G->pos, yythunkpos431= G->thunkpos;  if (!yy_Spacechar(G)) { goto l432; }  goto l431;
+  l432:;	  G->pos= yypos431; G->thunkpos= yythunkpos431;  if (!yy_Newline(G)) { goto l405; }
+  {  int yypos433= G->pos, yythunkpos433= G->thunkpos;  if (!yy_BlankLine(G)) { goto l433; }  goto l405;
+  l433:;	  G->pos= yypos433; G->thunkpos= yythunkpos433;
+  }
+  }
+  l431:;	
+  }
+  l420:;	  goto l404;
+  l405:;	  G->pos= yypos405; G->thunkpos= yythunkpos405;
+  }  if (!yy_Sp(G)) { goto l403; }  if (!yy_Ticks1(G)) { goto l403; }  goto l402;
+  l403:;	  G->pos= yypos402; G->thunkpos= yythunkpos402;  if (!yy_Ticks2(G)) { goto l434; }  yyDo(G, yySet, -1, 0);  if (!yy_Sp(G)) { goto l434; }
+  {  int yypos437= G->pos, yythunkpos437= G->thunkpos;
+  {  int yypos441= G->pos, yythunkpos441= G->thunkpos;  if (!yymatchChar(G, '`')) goto l441;  goto l438;
+  l441:;	  G->pos= yypos441; G->thunkpos= yythunkpos441;
+  }  if (!yy_Nonspacechar(G)) { goto l438; }
+  l439:;	
+  {  int yypos440= G->pos, yythunkpos440= G->thunkpos;
+  {  int yypos442= G->pos, yythunkpos442= G->thunkpos;  if (!yymatchChar(G, '`')) goto l442;  goto l440;
+  l442:;	  G->pos= yypos442; G->thunkpos= yythunkpos442;
+  }  if (!yy_Nonspacechar(G)) { goto l440; }  goto l439;
+  l440:;	  G->pos= yypos440; G->thunkpos= yythunkpos440;
+  }  goto l437;
+  l438:;	  G->pos= yypos437; G->thunkpos= yythunkpos437;
+  {  int yypos444= G->pos, yythunkpos444= G->thunkpos;  if (!yy_Ticks2(G)) { goto l444; }  goto l443;
+  l444:;	  G->pos= yypos444; G->thunkpos= yythunkpos444;
+  }  if (!yymatchChar(G, '`')) goto l443;
+  l445:;	
+  {  int yypos446= G->pos, yythunkpos446= G->thunkpos;  if (!yymatchChar(G, '`')) goto l446;  goto l445;
+  l446:;	  G->pos= yypos446; G->thunkpos= yythunkpos446;
+  }  goto l437;
+  l443:;	  G->pos= yypos437; G->thunkpos= yythunkpos437;
+  {  int yypos447= G->pos, yythunkpos447= G->thunkpos;  if (!yy_Sp(G)) { goto l447; }  if (!yy_Ticks2(G)) { goto l447; }  goto l434;
+  l447:;	  G->pos= yypos447; G->thunkpos= yythunkpos447;
+  }
+  {  int yypos448= G->pos, yythunkpos448= G->thunkpos;  if (!yy_Spacechar(G)) { goto l449; }  goto l448;
+  l449:;	  G->pos= yypos448; G->thunkpos= yythunkpos448;  if (!yy_Newline(G)) { goto l434; }
+  {  int yypos450= G->pos, yythunkpos450= G->thunkpos;  if (!yy_BlankLine(G)) { goto l450; }  goto l434;
+  l450:;	  G->pos= yypos450; G->thunkpos= yythunkpos450;
+  }
+  }
+  l448:;	
+  }
+  l437:;	
+  l435:;	
+  {  int yypos436= G->pos, yythunkpos436= G->thunkpos;
+  {  int yypos451= G->pos, yythunkpos451= G->thunkpos;
+  {  int yypos455= G->pos, yythunkpos455= G->thunkpos;  if (!yymatchChar(G, '`')) goto l455;  goto l452;
+  l455:;	  G->pos= yypos455; G->thunkpos= yythunkpos455;
+  }  if (!yy_Nonspacechar(G)) { goto l452; }
+  l453:;	
+  {  int yypos454= G->pos, yythunkpos454= G->thunkpos;
+  {  int yypos456= G->pos, yythunkpos456= G->thunkpos;  if (!yymatchChar(G, '`')) goto l456;  goto l454;
+  l456:;	  G->pos= yypos456; G->thunkpos= yythunkpos456;
+  }  if (!yy_Nonspacechar(G)) { goto l454; }  goto l453;
+  l454:;	  G->pos= yypos454; G->thunkpos= yythunkpos454;
+  }  goto l451;
+  l452:;	  G->pos= yypos451; G->thunkpos= yythunkpos451;
+  {  int yypos458= G->pos, yythunkpos458= G->thunkpos;  if (!yy_Ticks2(G)) { goto l458; }  goto l457;
+  l458:;	  G->pos= yypos458; G->thunkpos= yythunkpos458;
+  }  if (!yymatchChar(G, '`')) goto l457;
+  l459:;	
+  {  int yypos460= G->pos, yythunkpos460= G->thunkpos;  if (!yymatchChar(G, '`')) goto l460;  goto l459;
+  l460:;	  G->pos= yypos460; G->thunkpos= yythunkpos460;
+  }  goto l451;
+  l457:;	  G->pos= yypos451; G->thunkpos= yythunkpos451;
+  {  int yypos461= G->pos, yythunkpos461= G->thunkpos;  if (!yy_Sp(G)) { goto l461; }  if (!yy_Ticks2(G)) { goto l461; }  goto l436;
+  l461:;	  G->pos= yypos461; G->thunkpos= yythunkpos461;
+  }
+  {  int yypos462= G->pos, yythunkpos462= G->thunkpos;  if (!yy_Spacechar(G)) { goto l463; }  goto l462;
+  l463:;	  G->pos= yypos462; G->thunkpos= yythunkpos462;  if (!yy_Newline(G)) { goto l436; }
+  {  int yypos464= G->pos, yythunkpos464= G->thunkpos;  if (!yy_BlankLine(G)) { goto l464; }  goto l436;
+  l464:;	  G->pos= yypos464; G->thunkpos= yythunkpos464;
+  }
+  }
+  l462:;	
+  }
+  l451:;	  goto l435;
+  l436:;	  G->pos= yypos436; G->thunkpos= yythunkpos436;
+  }  if (!yy_Sp(G)) { goto l434; }  if (!yy_Ticks2(G)) { goto l434; }  goto l402;
+  l434:;	  G->pos= yypos402; G->thunkpos= yythunkpos402;  if (!yy_Ticks3(G)) { goto l465; }  yyDo(G, yySet, -1, 0);  if (!yy_Sp(G)) { goto l465; }
+  {  int yypos468= G->pos, yythunkpos468= G->thunkpos;
+  {  int yypos472= G->pos, yythunkpos472= G->thunkpos;  if (!yymatchChar(G, '`')) goto l472;  goto l469;
+  l472:;	  G->pos= yypos472; G->thunkpos= yythunkpos472;
+  }  if (!yy_Nonspacechar(G)) { goto l469; }
+  l470:;	
+  {  int yypos471= G->pos, yythunkpos471= G->thunkpos;
+  {  int yypos473= G->pos, yythunkpos473= G->thunkpos;  if (!yymatchChar(G, '`')) goto l473;  goto l471;
+  l473:;	  G->pos= yypos473; G->thunkpos= yythunkpos473;
+  }  if (!yy_Nonspacechar(G)) { goto l471; }  goto l470;
+  l471:;	  G->pos= yypos471; G->thunkpos= yythunkpos471;
+  }  goto l468;
+  l469:;	  G->pos= yypos468; G->thunkpos= yythunkpos468;
+  {  int yypos475= G->pos, yythunkpos475= G->thunkpos;  if (!yy_Ticks3(G)) { goto l475; }  goto l474;
+  l475:;	  G->pos= yypos475; G->thunkpos= yythunkpos475;
+  }  if (!yymatchChar(G, '`')) goto l474;
+  l476:;	
+  {  int yypos477= G->pos, yythunkpos477= G->thunkpos;  if (!yymatchChar(G, '`')) goto l477;  goto l476;
+  l477:;	  G->pos= yypos477; G->thunkpos= yythunkpos477;
+  }  goto l468;
+  l474:;	  G->pos= yypos468; G->thunkpos= yythunkpos468;
+  {  int yypos478= G->pos, yythunkpos478= G->thunkpos;  if (!yy_Sp(G)) { goto l478; }  if (!yy_Ticks3(G)) { goto l478; }  goto l465;
+  l478:;	  G->pos= yypos478; G->thunkpos= yythunkpos478;
+  }
+  {  int yypos479= G->pos, yythunkpos479= G->thunkpos;  if (!yy_Spacechar(G)) { goto l480; }  goto l479;
+  l480:;	  G->pos= yypos479; G->thunkpos= yythunkpos479;  if (!yy_Newline(G)) { goto l465; }
+  {  int yypos481= G->pos, yythunkpos481= G->thunkpos;  if (!yy_BlankLine(G)) { goto l481; }  goto l465;
+  l481:;	  G->pos= yypos481; G->thunkpos= yythunkpos481;
+  }
+  }
+  l479:;	
+  }
+  l468:;	
+  l466:;	
+  {  int yypos467= G->pos, yythunkpos467= G->thunkpos;
+  {  int yypos482= G->pos, yythunkpos482= G->thunkpos;
+  {  int yypos486= G->pos, yythunkpos486= G->thunkpos;  if (!yymatchChar(G, '`')) goto l486;  goto l483;
+  l486:;	  G->pos= yypos486; G->thunkpos= yythunkpos486;
+  }  if (!yy_Nonspacechar(G)) { goto l483; }
+  l484:;	
+  {  int yypos485= G->pos, yythunkpos485= G->thunkpos;
+  {  int yypos487= G->pos, yythunkpos487= G->thunkpos;  if (!yymatchChar(G, '`')) goto l487;  goto l485;
+  l487:;	  G->pos= yypos487; G->thunkpos= yythunkpos487;
+  }  if (!yy_Nonspacechar(G)) { goto l485; }  goto l484;
+  l485:;	  G->pos= yypos485; G->thunkpos= yythunkpos485;
+  }  goto l482;
+  l483:;	  G->pos= yypos482; G->thunkpos= yythunkpos482;
+  {  int yypos489= G->pos, yythunkpos489= G->thunkpos;  if (!yy_Ticks3(G)) { goto l489; }  goto l488;
+  l489:;	  G->pos= yypos489; G->thunkpos= yythunkpos489;
+  }  if (!yymatchChar(G, '`')) goto l488;
+  l490:;	
+  {  int yypos491= G->pos, yythunkpos491= G->thunkpos;  if (!yymatchChar(G, '`')) goto l491;  goto l490;
+  l491:;	  G->pos= yypos491; G->thunkpos= yythunkpos491;
+  }  goto l482;
+  l488:;	  G->pos= yypos482; G->thunkpos= yythunkpos482;
+  {  int yypos492= G->pos, yythunkpos492= G->thunkpos;  if (!yy_Sp(G)) { goto l492; }  if (!yy_Ticks3(G)) { goto l492; }  goto l467;
+  l492:;	  G->pos= yypos492; G->thunkpos= yythunkpos492;
+  }
+  {  int yypos493= G->pos, yythunkpos493= G->thunkpos;  if (!yy_Spacechar(G)) { goto l494; }  goto l493;
+  l494:;	  G->pos= yypos493; G->thunkpos= yythunkpos493;  if (!yy_Newline(G)) { goto l467; }
+  {  int yypos495= G->pos, yythunkpos495= G->thunkpos;  if (!yy_BlankLine(G)) { goto l495; }  goto l467;
+  l495:;	  G->pos= yypos495; G->thunkpos= yythunkpos495;
+  }
+  }
+  l493:;	
+  }
+  l482:;	  goto l466;
+  l467:;	  G->pos= yypos467; G->thunkpos= yythunkpos467;
+  }  if (!yy_Sp(G)) { goto l465; }  if (!yy_Ticks3(G)) { goto l465; }  goto l402;
+  l465:;	  G->pos= yypos402; G->thunkpos= yythunkpos402;  if (!yy_Ticks4(G)) { goto l496; }  yyDo(G, yySet, -1, 0);  if (!yy_Sp(G)) { goto l496; }
+  {  int yypos499= G->pos, yythunkpos499= G->thunkpos;
+  {  int yypos503= G->pos, yythunkpos503= G->thunkpos;  if (!yymatchChar(G, '`')) goto l503;  goto l500;
+  l503:;	  G->pos= yypos503; G->thunkpos= yythunkpos503;
+  }  if (!yy_Nonspacechar(G)) { goto l500; }
+  l501:;	
+  {  int yypos502= G->pos, yythunkpos502= G->thunkpos;
+  {  int yypos504= G->pos, yythunkpos504= G->thunkpos;  if (!yymatchChar(G, '`')) goto l504;  goto l502;
+  l504:;	  G->pos= yypos504; G->thunkpos= yythunkpos504;
+  }  if (!yy_Nonspacechar(G)) { goto l502; }  goto l501;
+  l502:;	  G->pos= yypos502; G->thunkpos= yythunkpos502;
+  }  goto l499;
+  l500:;	  G->pos= yypos499; G->thunkpos= yythunkpos499;
+  {  int yypos506= G->pos, yythunkpos506= G->thunkpos;  if (!yy_Ticks4(G)) { goto l506; }  goto l505;
+  l506:;	  G->pos= yypos506; G->thunkpos= yythunkpos506;
+  }  if (!yymatchChar(G, '`')) goto l505;
+  l507:;	
+  {  int yypos508= G->pos, yythunkpos508= G->thunkpos;  if (!yymatchChar(G, '`')) goto l508;  goto l507;
+  l508:;	  G->pos= yypos508; G->thunkpos= yythunkpos508;
+  }  goto l499;
+  l505:;	  G->pos= yypos499; G->thunkpos= yythunkpos499;
+  {  int yypos509= G->pos, yythunkpos509= G->thunkpos;  if (!yy_Sp(G)) { goto l509; }  if (!yy_Ticks4(G)) { goto l509; }  goto l496;
+  l509:;	  G->pos= yypos509; G->thunkpos= yythunkpos509;
+  }
+  {  int yypos510= G->pos, yythunkpos510= G->thunkpos;  if (!yy_Spacechar(G)) { goto l511; }  goto l510;
+  l511:;	  G->pos= yypos510; G->thunkpos= yythunkpos510;  if (!yy_Newline(G)) { goto l496; }
+  {  int yypos512= G->pos, yythunkpos512= G->thunkpos;  if (!yy_BlankLine(G)) { goto l512; }  goto l496;
+  l512:;	  G->pos= yypos512; G->thunkpos= yythunkpos512;
+  }
+  }
+  l510:;	
+  }
+  l499:;	
+  l497:;	
+  {  int yypos498= G->pos, yythunkpos498= G->thunkpos;
+  {  int yypos513= G->pos, yythunkpos513= G->thunkpos;
+  {  int yypos517= G->pos, yythunkpos517= G->thunkpos;  if (!yymatchChar(G, '`')) goto l517;  goto l514;
+  l517:;	  G->pos= yypos517; G->thunkpos= yythunkpos517;
+  }  if (!yy_Nonspacechar(G)) { goto l514; }
+  l515:;	
+  {  int yypos516= G->pos, yythunkpos516= G->thunkpos;
+  {  int yypos518= G->pos, yythunkpos518= G->thunkpos;  if (!yymatchChar(G, '`')) goto l518;  goto l516;
+  l518:;	  G->pos= yypos518; G->thunkpos= yythunkpos518;
+  }  if (!yy_Nonspacechar(G)) { goto l516; }  goto l515;
+  l516:;	  G->pos= yypos516; G->thunkpos= yythunkpos516;
+  }  goto l513;
+  l514:;	  G->pos= yypos513; G->thunkpos= yythunkpos513;
+  {  int yypos520= G->pos, yythunkpos520= G->thunkpos;  if (!yy_Ticks4(G)) { goto l520; }  goto l519;
+  l520:;	  G->pos= yypos520; G->thunkpos= yythunkpos520;
+  }  if (!yymatchChar(G, '`')) goto l519;
+  l521:;	
+  {  int yypos522= G->pos, yythunkpos522= G->thunkpos;  if (!yymatchChar(G, '`')) goto l522;  goto l521;
+  l522:;	  G->pos= yypos522; G->thunkpos= yythunkpos522;
+  }  goto l513;
+  l519:;	  G->pos= yypos513; G->thunkpos= yythunkpos513;
+  {  int yypos523= G->pos, yythunkpos523= G->thunkpos;  if (!yy_Sp(G)) { goto l523; }  if (!yy_Ticks4(G)) { goto l523; }  goto l498;
+  l523:;	  G->pos= yypos523; G->thunkpos= yythunkpos523;
+  }
+  {  int yypos524= G->pos, yythunkpos524= G->thunkpos;  if (!yy_Spacechar(G)) { goto l525; }  goto l524;
+  l525:;	  G->pos= yypos524; G->thunkpos= yythunkpos524;  if (!yy_Newline(G)) { goto l498; }
+  {  int yypos526= G->pos, yythunkpos526= G->thunkpos;  if (!yy_BlankLine(G)) { goto l526; }  goto l498;
+  l526:;	  G->pos= yypos526; G->thunkpos= yythunkpos526;
+  }
+  }
+  l524:;	
+  }
+  l513:;	  goto l497;
+  l498:;	  G->pos= yypos498; G->thunkpos= yythunkpos498;
+  }  if (!yy_Sp(G)) { goto l496; }  if (!yy_Ticks4(G)) { goto l496; }  goto l402;
+  l496:;	  G->pos= yypos402; G->thunkpos= yythunkpos402;  if (!yy_Ticks5(G)) { goto l401; }  yyDo(G, yySet, -1, 0);  if (!yy_Sp(G)) { goto l401; }
+  {  int yypos529= G->pos, yythunkpos529= G->thunkpos;
+  {  int yypos533= G->pos, yythunkpos533= G->thunkpos;  if (!yymatchChar(G, '`')) goto l533;  goto l530;
+  l533:;	  G->pos= yypos533; G->thunkpos= yythunkpos533;
+  }  if (!yy_Nonspacechar(G)) { goto l530; }
+  l531:;	
+  {  int yypos532= G->pos, yythunkpos532= G->thunkpos;
+  {  int yypos534= G->pos, yythunkpos534= G->thunkpos;  if (!yymatchChar(G, '`')) goto l534;  goto l532;
+  l534:;	  G->pos= yypos534; G->thunkpos= yythunkpos534;
+  }  if (!yy_Nonspacechar(G)) { goto l532; }  goto l531;
+  l532:;	  G->pos= yypos532; G->thunkpos= yythunkpos532;
+  }  goto l529;
+  l530:;	  G->pos= yypos529; G->thunkpos= yythunkpos529;
+  {  int yypos536= G->pos, yythunkpos536= G->thunkpos;  if (!yy_Ticks5(G)) { goto l536; }  goto l535;
+  l536:;	  G->pos= yypos536; G->thunkpos= yythunkpos536;
+  }  if (!yymatchChar(G, '`')) goto l535;
+  l537:;	
+  {  int yypos538= G->pos, yythunkpos538= G->thunkpos;  if (!yymatchChar(G, '`')) goto l538;  goto l537;
+  l538:;	  G->pos= yypos538; G->thunkpos= yythunkpos538;
+  }  goto l529;
+  l535:;	  G->pos= yypos529; G->thunkpos= yythunkpos529;
+  {  int yypos539= G->pos, yythunkpos539= G->thunkpos;  if (!yy_Sp(G)) { goto l539; }  if (!yy_Ticks5(G)) { goto l539; }  goto l401;
+  l539:;	  G->pos= yypos539; G->thunkpos= yythunkpos539;
+  }
+  {  int yypos540= G->pos, yythunkpos540= G->thunkpos;  if (!yy_Spacechar(G)) { goto l541; }  goto l540;
+  l541:;	  G->pos= yypos540; G->thunkpos= yythunkpos540;  if (!yy_Newline(G)) { goto l401; }
+  {  int yypos542= G->pos, yythunkpos542= G->thunkpos;  if (!yy_BlankLine(G)) { goto l542; }  goto l401;
+  l542:;	  G->pos= yypos542; G->thunkpos= yythunkpos542;
+  }
+  }
+  l540:;	
+  }
+  l529:;	
+  l527:;	
+  {  int yypos528= G->pos, yythunkpos528= G->thunkpos;
+  {  int yypos543= G->pos, yythunkpos543= G->thunkpos;
+  {  int yypos547= G->pos, yythunkpos547= G->thunkpos;  if (!yymatchChar(G, '`')) goto l547;  goto l544;
+  l547:;	  G->pos= yypos547; G->thunkpos= yythunkpos547;
+  }  if (!yy_Nonspacechar(G)) { goto l544; }
+  l545:;	
+  {  int yypos546= G->pos, yythunkpos546= G->thunkpos;
+  {  int yypos548= G->pos, yythunkpos548= G->thunkpos;  if (!yymatchChar(G, '`')) goto l548;  goto l546;
+  l548:;	  G->pos= yypos548; G->thunkpos= yythunkpos548;
+  }  if (!yy_Nonspacechar(G)) { goto l546; }  goto l545;
+  l546:;	  G->pos= yypos546; G->thunkpos= yythunkpos546;
+  }  goto l543;
+  l544:;	  G->pos= yypos543; G->thunkpos= yythunkpos543;
+  {  int yypos550= G->pos, yythunkpos550= G->thunkpos;  if (!yy_Ticks5(G)) { goto l550; }  goto l549;
+  l550:;	  G->pos= yypos550; G->thunkpos= yythunkpos550;
+  }  if (!yymatchChar(G, '`')) goto l549;
+  l551:;	
+  {  int yypos552= G->pos, yythunkpos552= G->thunkpos;  if (!yymatchChar(G, '`')) goto l552;  goto l551;
+  l552:;	  G->pos= yypos552; G->thunkpos= yythunkpos552;
+  }  goto l543;
+  l549:;	  G->pos= yypos543; G->thunkpos= yythunkpos543;
+  {  int yypos553= G->pos, yythunkpos553= G->thunkpos;  if (!yy_Sp(G)) { goto l553; }  if (!yy_Ticks5(G)) { goto l553; }  goto l528;
+  l553:;	  G->pos= yypos553; G->thunkpos= yythunkpos553;
+  }
+  {  int yypos554= G->pos, yythunkpos554= G->thunkpos;  if (!yy_Spacechar(G)) { goto l555; }  goto l554;
+  l555:;	  G->pos= yypos554; G->thunkpos= yythunkpos554;  if (!yy_Newline(G)) { goto l528; }
+  {  int yypos556= G->pos, yythunkpos556= G->thunkpos;  if (!yy_BlankLine(G)) { goto l556; }  goto l528;
+  l556:;	  G->pos= yypos556; G->thunkpos= yythunkpos556;
+  }
+  }
+  l554:;	
+  }
+  l543:;	  goto l527;
+  l528:;	  G->pos= yypos528; G->thunkpos= yythunkpos528;
+  }  if (!yy_Sp(G)) { goto l401; }  if (!yy_Ticks5(G)) { goto l401; }
+  }
+  l402:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l401;  yyDo(G, yy_1_Code, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Code", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l401:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Code", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_InlineNote(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "InlineNote"));  yyText(G, G->begin, G->end);  if (!( EXT(pmh_EXT_NOTES) )) goto l557;  if (!yymatchString(G, "^[")) goto l557;
+  {  int yypos560= G->pos, yythunkpos560= G->thunkpos;  if (!yymatchChar(G, ']')) goto l560;  goto l557;
+  l560:;	  G->pos= yypos560; G->thunkpos= yythunkpos560;
+  }  if (!yy_Inline(G)) { goto l557; }
+  l558:;	
+  {  int yypos559= G->pos, yythunkpos559= G->thunkpos;
+  {  int yypos561= G->pos, yythunkpos561= G->thunkpos;  if (!yymatchChar(G, ']')) goto l561;  goto l559;
+  l561:;	  G->pos= yypos561; G->thunkpos= yythunkpos561;
+  }  if (!yy_Inline(G)) { goto l559; }  goto l558;
+  l559:;	  G->pos= yypos559; G->thunkpos= yythunkpos559;
+  }  if (!yymatchChar(G, ']')) goto l557;
+  yyprintf((stderr, "  ok   %s @ %s\n", "InlineNote", G->buf+G->pos));
+  return 1;
+  l557:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "InlineNote", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_NoteReference(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "NoteReference"));  yyText(G, G->begin, G->end);  if (!( EXT(pmh_EXT_NOTES) )) goto l562;  if (!yy_RawNoteReference(G)) { goto l562; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "NoteReference", G->buf+G->pos));
+  return 1;
+  l562:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "NoteReference", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Link(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Link"));
+  {  int yypos564= G->pos, yythunkpos564= G->thunkpos;  if (!yy_ExplicitLink(G)) { goto l565; }  goto l564;
+  l565:;	  G->pos= yypos564; G->thunkpos= yythunkpos564;  if (!yy_ReferenceLink(G)) { goto l566; }  goto l564;
+  l566:;	  G->pos= yypos564; G->thunkpos= yythunkpos564;  if (!yy_AutoLink(G)) { goto l563; }
+  }
+  l564:;	  yyDo(G, yy_1_Link, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Link", G->buf+G->pos));
+  return 1;
+  l563:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Link", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Image(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Image"));  if (!yymatchChar(G, '!')) goto l567;
+  {  int yypos568= G->pos, yythunkpos568= G->thunkpos;  if (!yy_ExplicitLink(G)) { goto l569; }  goto l568;
+  l569:;	  G->pos= yypos568; G->thunkpos= yythunkpos568;  if (!yy_ReferenceLink(G)) { goto l567; }
+  }
+  l568:;	  yyDo(G, yy_1_Image, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Image", G->buf+G->pos));
+  return 1;
+  l567:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Image", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Strike(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "Strike"));  yyText(G, G->begin, G->end);  if (!( EXT(pmh_EXT_STRIKE) )) goto l570;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l570;  if (!yy_LocMarker(G)) { goto l570; }  yyDo(G, yySet, -1, 0);  if (!yymatchString(G, "~~")) goto l570;
+  {  int yypos571= G->pos, yythunkpos571= G->thunkpos;  if (!yy_Whitespace(G)) { goto l571; }  goto l570;
+  l571:;	  G->pos= yypos571; G->thunkpos= yythunkpos571;
+  }
+  {  int yypos574= G->pos, yythunkpos574= G->thunkpos;  if (!yymatchString(G, "~~")) goto l574;  goto l570;
+  l574:;	  G->pos= yypos574; G->thunkpos= yythunkpos574;
+  }  if (!yy_Inline(G)) { goto l570; }
+  l572:;	
+  {  int yypos573= G->pos, yythunkpos573= G->thunkpos;
+  {  int yypos575= G->pos, yythunkpos575= G->thunkpos;  if (!yymatchString(G, "~~")) goto l575;  goto l573;
+  l575:;	  G->pos= yypos575; G->thunkpos= yythunkpos575;
+  }  if (!yy_Inline(G)) { goto l573; }  goto l572;
+  l573:;	  G->pos= yypos573; G->thunkpos= yythunkpos573;
+  }  if (!yymatchString(G, "~~")) goto l570;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l570;  yyDo(G, yy_1_Strike, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Strike", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l570:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Strike", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Emph(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Emph"));
+  {  int yypos577= G->pos, yythunkpos577= G->thunkpos;  if (!yy_EmphStar(G)) { goto l578; }  goto l577;
+  l578:;	  G->pos= yypos577; G->thunkpos= yythunkpos577;  if (!yy_EmphUl(G)) { goto l576; }
+  }
+  l577:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Emph", G->buf+G->pos));
+  return 1;
+  l576:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Emph", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Strong(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Strong"));
+  {  int yypos580= G->pos, yythunkpos580= G->thunkpos;  if (!yy_StrongStar(G)) { goto l581; }  goto l580;
+  l581:;	  G->pos= yypos580; G->thunkpos= yythunkpos580;  if (!yy_StrongUl(G)) { goto l579; }
+  }
+  l580:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Strong", G->buf+G->pos));
+  return 1;
+  l579:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Strong", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Space(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Space"));  if (!yy_Spacechar(G)) { goto l582; }
+  l583:;	
+  {  int yypos584= G->pos, yythunkpos584= G->thunkpos;  if (!yy_Spacechar(G)) { goto l584; }  goto l583;
+  l584:;	  G->pos= yypos584; G->thunkpos= yythunkpos584;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Space", G->buf+G->pos));
+  return 1;
+  l582:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Space", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_UlOrStarLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "UlOrStarLine"));
+  {  int yypos586= G->pos, yythunkpos586= G->thunkpos;  if (!yy_UlLine(G)) { goto l587; }  goto l586;
+  l587:;	  G->pos= yypos586; G->thunkpos= yythunkpos586;  if (!yy_StarLine(G)) { goto l585; }
+  }
+  l586:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "UlOrStarLine", G->buf+G->pos));
+  return 1;
+  l585:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "UlOrStarLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Str(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Str"));  if (!yy_NormalChar(G)) { goto l588; }
+  l589:;	
+  {  int yypos590= G->pos, yythunkpos590= G->thunkpos;
+  {  int yypos591= G->pos, yythunkpos591= G->thunkpos;  if (!yy_NormalChar(G)) { goto l592; }  goto l591;
+  l592:;	  G->pos= yypos591; G->thunkpos= yythunkpos591;  if (!yymatchChar(G, '_')) goto l590;
+  l593:;	
+  {  int yypos594= G->pos, yythunkpos594= G->thunkpos;  if (!yymatchChar(G, '_')) goto l594;  goto l593;
+  l594:;	  G->pos= yypos594; G->thunkpos= yythunkpos594;
+  }
+  {  int yypos595= G->pos, yythunkpos595= G->thunkpos;  if (!yy_Alphanumeric(G)) { goto l590; }  G->pos= yypos595; G->thunkpos= yythunkpos595;
+  }
+  }
+  l591:;	  goto l589;
+  l590:;	  G->pos= yypos590; G->thunkpos= yythunkpos590;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Str", G->buf+G->pos));
+  return 1;
+  l588:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Str", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_InStyleTags(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "InStyleTags"));  if (!yy_StyleOpen(G)) { goto l596; }
+  l597:;	
+  {  int yypos598= G->pos, yythunkpos598= G->thunkpos;
+  {  int yypos599= G->pos, yythunkpos599= G->thunkpos;  if (!yy_StyleClose(G)) { goto l599; }  goto l598;
+  l599:;	  G->pos= yypos599; G->thunkpos= yythunkpos599;
+  }  if (!yymatchDot(G)) goto l598;  goto l597;
+  l598:;	  G->pos= yypos598; G->thunkpos= yythunkpos598;
+  }  if (!yy_StyleClose(G)) { goto l596; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "InStyleTags", G->buf+G->pos));
+  return 1;
+  l596:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "InStyleTags", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_StyleClose(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "StyleClose"));  if (!yymatchChar(G, '<')) goto l600;  if (!yy_Spnl(G)) { goto l600; }  if (!yymatchChar(G, '/')) goto l600;
+  {  int yypos601= G->pos, yythunkpos601= G->thunkpos;  if (!yymatchString(G, "style")) goto l602;  goto l601;
+  l602:;	  G->pos= yypos601; G->thunkpos= yythunkpos601;  if (!yymatchString(G, "STYLE")) goto l600;
+  }
+  l601:;	  if (!yy_Spnl(G)) { goto l600; }  if (!yymatchChar(G, '>')) goto l600;
+  yyprintf((stderr, "  ok   %s @ %s\n", "StyleClose", G->buf+G->pos));
+  return 1;
+  l600:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "StyleClose", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_StyleOpen(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "StyleOpen"));  if (!yymatchChar(G, '<')) goto l603;  if (!yy_Spnl(G)) { goto l603; }
+  {  int yypos604= G->pos, yythunkpos604= G->thunkpos;  if (!yymatchString(G, "style")) goto l605;  goto l604;
+  l605:;	  G->pos= yypos604; G->thunkpos= yythunkpos604;  if (!yymatchString(G, "STYLE")) goto l603;
+  }
+  l604:;	  if (!yy_Spnl(G)) { goto l603; }
+  l606:;	
+  {  int yypos607= G->pos, yythunkpos607= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l607; }  goto l606;
+  l607:;	  G->pos= yypos607; G->thunkpos= yythunkpos607;
+  }  if (!yymatchChar(G, '>')) goto l603;
+  yyprintf((stderr, "  ok   %s @ %s\n", "StyleOpen", G->buf+G->pos));
+  return 1;
+  l603:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "StyleOpen", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockType(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockType"));
+  {  int yypos609= G->pos, yythunkpos609= G->thunkpos;  if (!yymatchString(G, "address")) goto l610;  goto l609;
+  l610:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "blockquote")) goto l611;  goto l609;
+  l611:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "center")) goto l612;  goto l609;
+  l612:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "dir")) goto l613;  goto l609;
+  l613:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "div")) goto l614;  goto l609;
+  l614:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "dl")) goto l615;  goto l609;
+  l615:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "fieldset")) goto l616;  goto l609;
+  l616:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "form")) goto l617;  goto l609;
+  l617:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "h1")) goto l618;  goto l609;
+  l618:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "h2")) goto l619;  goto l609;
+  l619:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "h3")) goto l620;  goto l609;
+  l620:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "h4")) goto l621;  goto l609;
+  l621:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "h5")) goto l622;  goto l609;
+  l622:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "h6")) goto l623;  goto l609;
+  l623:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "hr")) goto l624;  goto l609;
+  l624:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "isindex")) goto l625;  goto l609;
+  l625:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "menu")) goto l626;  goto l609;
+  l626:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "noframes")) goto l627;  goto l609;
+  l627:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "noscript")) goto l628;  goto l609;
+  l628:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "ol")) goto l629;  goto l609;
+  l629:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchChar(G, 'p')) goto l630;  goto l609;
+  l630:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "pre")) goto l631;  goto l609;
+  l631:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "table")) goto l632;  goto l609;
+  l632:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "ul")) goto l633;  goto l609;
+  l633:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "dd")) goto l634;  goto l609;
+  l634:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "dt")) goto l635;  goto l609;
+  l635:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "frameset")) goto l636;  goto l609;
+  l636:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "li")) goto l637;  goto l609;
+  l637:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "tbody")) goto l638;  goto l609;
+  l638:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "td")) goto l639;  goto l609;
+  l639:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "tfoot")) goto l640;  goto l609;
+  l640:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "th")) goto l641;  goto l609;
+  l641:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "thead")) goto l642;  goto l609;
+  l642:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "tr")) goto l643;  goto l609;
+  l643:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "script")) goto l644;  goto l609;
+  l644:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "ADDRESS")) goto l645;  goto l609;
+  l645:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "BLOCKQUOTE")) goto l646;  goto l609;
+  l646:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "CENTER")) goto l647;  goto l609;
+  l647:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "DIR")) goto l648;  goto l609;
+  l648:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "DIV")) goto l649;  goto l609;
+  l649:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "DL")) goto l650;  goto l609;
+  l650:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "FIELDSET")) goto l651;  goto l609;
+  l651:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "FORM")) goto l652;  goto l609;
+  l652:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "H1")) goto l653;  goto l609;
+  l653:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "H2")) goto l654;  goto l609;
+  l654:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "H3")) goto l655;  goto l609;
+  l655:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "H4")) goto l656;  goto l609;
+  l656:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "H5")) goto l657;  goto l609;
+  l657:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "H6")) goto l658;  goto l609;
+  l658:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "HR")) goto l659;  goto l609;
+  l659:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "ISINDEX")) goto l660;  goto l609;
+  l660:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "MENU")) goto l661;  goto l609;
+  l661:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "NOFRAMES")) goto l662;  goto l609;
+  l662:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "NOSCRIPT")) goto l663;  goto l609;
+  l663:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "OL")) goto l664;  goto l609;
+  l664:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchChar(G, 'P')) goto l665;  goto l609;
+  l665:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "PRE")) goto l666;  goto l609;
+  l666:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "TABLE")) goto l667;  goto l609;
+  l667:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "UL")) goto l668;  goto l609;
+  l668:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "DD")) goto l669;  goto l609;
+  l669:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "DT")) goto l670;  goto l609;
+  l670:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "FRAMESET")) goto l671;  goto l609;
+  l671:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "LI")) goto l672;  goto l609;
+  l672:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "TBODY")) goto l673;  goto l609;
+  l673:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "TD")) goto l674;  goto l609;
+  l674:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "TFOOT")) goto l675;  goto l609;
+  l675:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "TH")) goto l676;  goto l609;
+  l676:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "THEAD")) goto l677;  goto l609;
+  l677:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "TR")) goto l678;  goto l609;
+  l678:;	  G->pos= yypos609; G->thunkpos= yythunkpos609;  if (!yymatchString(G, "SCRIPT")) goto l608;
+  }
+  l609:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockType", G->buf+G->pos));
+  return 1;
+  l608:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockType", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockSelfClosing(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockSelfClosing"));  if (!yymatchChar(G, '<')) goto l679;  if (!yy_Spnl(G)) { goto l679; }  if (!yy_HtmlBlockType(G)) { goto l679; }  if (!yy_Spnl(G)) { goto l679; }
+  l680:;	
+  {  int yypos681= G->pos, yythunkpos681= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l681; }  goto l680;
+  l681:;	  G->pos= yypos681; G->thunkpos= yythunkpos681;
+  }  if (!yymatchChar(G, '/')) goto l679;  if (!yy_Spnl(G)) { goto l679; }  if (!yymatchChar(G, '>')) goto l679;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockSelfClosing", G->buf+G->pos));
+  return 1;
+  l679:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockSelfClosing", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlComment(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlComment"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l682;  if (!yy_LocMarker(G)) { goto l682; }  yyDo(G, yySet, -1, 0);  if (!yymatchString(G, "<!--")) goto l682;
+  l683:;	
+  {  int yypos684= G->pos, yythunkpos684= G->thunkpos;
+  {  int yypos685= G->pos, yythunkpos685= G->thunkpos;  if (!yymatchString(G, "-->")) goto l685;  goto l684;
+  l685:;	  G->pos= yypos685; G->thunkpos= yythunkpos685;
+  }  if (!yymatchDot(G)) goto l684;  goto l683;
+  l684:;	  G->pos= yypos684; G->thunkpos= yythunkpos684;
+  }  if (!yymatchString(G, "-->")) goto l682;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l682;  yyDo(G, yy_1_HtmlComment, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlComment", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l682:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlComment", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockInTags(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockInTags"));
+  {  int yypos687= G->pos, yythunkpos687= G->thunkpos;  if (!yy_HtmlBlockAddress(G)) { goto l688; }  goto l687;
+  l688:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockBlockquote(G)) { goto l689; }  goto l687;
+  l689:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockCenter(G)) { goto l690; }  goto l687;
+  l690:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockDir(G)) { goto l691; }  goto l687;
+  l691:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockDiv(G)) { goto l692; }  goto l687;
+  l692:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockDl(G)) { goto l693; }  goto l687;
+  l693:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockFieldset(G)) { goto l694; }  goto l687;
+  l694:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockForm(G)) { goto l695; }  goto l687;
+  l695:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockH1(G)) { goto l696; }  goto l687;
+  l696:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockH2(G)) { goto l697; }  goto l687;
+  l697:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockH3(G)) { goto l698; }  goto l687;
+  l698:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockH4(G)) { goto l699; }  goto l687;
+  l699:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockH5(G)) { goto l700; }  goto l687;
+  l700:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockH6(G)) { goto l701; }  goto l687;
+  l701:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockMenu(G)) { goto l702; }  goto l687;
+  l702:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockNoframes(G)) { goto l703; }  goto l687;
+  l703:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockNoscript(G)) { goto l704; }  goto l687;
+  l704:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockOl(G)) { goto l705; }  goto l687;
+  l705:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockP(G)) { goto l706; }  goto l687;
+  l706:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockPre(G)) { goto l707; }  goto l687;
+  l707:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockTable(G)) { goto l708; }  goto l687;
+  l708:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockUl(G)) { goto l709; }  goto l687;
+  l709:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockDd(G)) { goto l710; }  goto l687;
+  l710:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockDt(G)) { goto l711; }  goto l687;
+  l711:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockFrameset(G)) { goto l712; }  goto l687;
+  l712:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockLi(G)) { goto l713; }  goto l687;
+  l713:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockTbody(G)) { goto l714; }  goto l687;
+  l714:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockTd(G)) { goto l715; }  goto l687;
+  l715:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockTfoot(G)) { goto l716; }  goto l687;
+  l716:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockTh(G)) { goto l717; }  goto l687;
+  l717:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockThead(G)) { goto l718; }  goto l687;
+  l718:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockTr(G)) { goto l719; }  goto l687;
+  l719:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockScript(G)) { goto l720; }  goto l687;
+  l720:;	  G->pos= yypos687; G->thunkpos= yythunkpos687;  if (!yy_HtmlBlockHead(G)) { goto l686; }
+  }
+  l687:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockInTags", G->buf+G->pos));
+  return 1;
+  l686:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockInTags", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockHead(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockHead"));  if (!yy_HtmlBlockOpenHead(G)) { goto l721; }
+  l722:;	
+  {  int yypos723= G->pos, yythunkpos723= G->thunkpos;
+  {  int yypos724= G->pos, yythunkpos724= G->thunkpos;  if (!yy_HtmlBlockCloseHead(G)) { goto l724; }  goto l723;
+  l724:;	  G->pos= yypos724; G->thunkpos= yythunkpos724;
+  }  if (!yymatchDot(G)) goto l723;  goto l722;
+  l723:;	  G->pos= yypos723; G->thunkpos= yythunkpos723;
+  }  if (!yy_HtmlBlockCloseHead(G)) { goto l721; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockHead", G->buf+G->pos));
+  return 1;
+  l721:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockHead", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseHead(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseHead"));  if (!yymatchChar(G, '<')) goto l725;  if (!yy_Spnl(G)) { goto l725; }  if (!yymatchChar(G, '/')) goto l725;
+  {  int yypos726= G->pos, yythunkpos726= G->thunkpos;  if (!yymatchString(G, "head")) goto l727;  goto l726;
+  l727:;	  G->pos= yypos726; G->thunkpos= yythunkpos726;  if (!yymatchString(G, "HEAD")) goto l725;
+  }
+  l726:;	  if (!yy_Spnl(G)) { goto l725; }  if (!yymatchChar(G, '>')) goto l725;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseHead", G->buf+G->pos));
+  return 1;
+  l725:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseHead", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenHead(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenHead"));  if (!yymatchChar(G, '<')) goto l728;  if (!yy_Spnl(G)) { goto l728; }
+  {  int yypos729= G->pos, yythunkpos729= G->thunkpos;  if (!yymatchString(G, "head")) goto l730;  goto l729;
+  l730:;	  G->pos= yypos729; G->thunkpos= yythunkpos729;  if (!yymatchString(G, "HEAD")) goto l728;
+  }
+  l729:;	  if (!yy_Spnl(G)) { goto l728; }
+  l731:;	
+  {  int yypos732= G->pos, yythunkpos732= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l732; }  goto l731;
+  l732:;	  G->pos= yypos732; G->thunkpos= yythunkpos732;
+  }  if (!yymatchChar(G, '>')) goto l728;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenHead", G->buf+G->pos));
+  return 1;
+  l728:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenHead", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockScript(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockScript"));  if (!yy_HtmlBlockOpenScript(G)) { goto l733; }
+  l734:;	
+  {  int yypos735= G->pos, yythunkpos735= G->thunkpos;
+  {  int yypos736= G->pos, yythunkpos736= G->thunkpos;  if (!yy_HtmlBlockCloseScript(G)) { goto l736; }  goto l735;
+  l736:;	  G->pos= yypos736; G->thunkpos= yythunkpos736;
+  }  if (!yymatchDot(G)) goto l735;  goto l734;
+  l735:;	  G->pos= yypos735; G->thunkpos= yythunkpos735;
+  }  if (!yy_HtmlBlockCloseScript(G)) { goto l733; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockScript", G->buf+G->pos));
+  return 1;
+  l733:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockScript", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseScript(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseScript"));  if (!yymatchChar(G, '<')) goto l737;  if (!yy_Spnl(G)) { goto l737; }  if (!yymatchChar(G, '/')) goto l737;
+  {  int yypos738= G->pos, yythunkpos738= G->thunkpos;  if (!yymatchString(G, "script")) goto l739;  goto l738;
+  l739:;	  G->pos= yypos738; G->thunkpos= yythunkpos738;  if (!yymatchString(G, "SCRIPT")) goto l737;
+  }
+  l738:;	  if (!yy_Spnl(G)) { goto l737; }  if (!yymatchChar(G, '>')) goto l737;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseScript", G->buf+G->pos));
+  return 1;
+  l737:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseScript", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenScript(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenScript"));  if (!yymatchChar(G, '<')) goto l740;  if (!yy_Spnl(G)) { goto l740; }
+  {  int yypos741= G->pos, yythunkpos741= G->thunkpos;  if (!yymatchString(G, "script")) goto l742;  goto l741;
+  l742:;	  G->pos= yypos741; G->thunkpos= yythunkpos741;  if (!yymatchString(G, "SCRIPT")) goto l740;
+  }
+  l741:;	  if (!yy_Spnl(G)) { goto l740; }
+  l743:;	
+  {  int yypos744= G->pos, yythunkpos744= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l744; }  goto l743;
+  l744:;	  G->pos= yypos744; G->thunkpos= yythunkpos744;
+  }  if (!yymatchChar(G, '>')) goto l740;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenScript", G->buf+G->pos));
+  return 1;
+  l740:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenScript", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockTr(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockTr"));  if (!yy_HtmlBlockOpenTr(G)) { goto l745; }
+  l746:;	
+  {  int yypos747= G->pos, yythunkpos747= G->thunkpos;
+  {  int yypos748= G->pos, yythunkpos748= G->thunkpos;  if (!yy_HtmlBlockTr(G)) { goto l749; }  goto l748;
+  l749:;	  G->pos= yypos748; G->thunkpos= yythunkpos748;
+  {  int yypos750= G->pos, yythunkpos750= G->thunkpos;  if (!yy_HtmlBlockCloseTr(G)) { goto l750; }  goto l747;
+  l750:;	  G->pos= yypos750; G->thunkpos= yythunkpos750;
+  }  if (!yymatchDot(G)) goto l747;
+  }
+  l748:;	  goto l746;
+  l747:;	  G->pos= yypos747; G->thunkpos= yythunkpos747;
+  }  if (!yy_HtmlBlockCloseTr(G)) { goto l745; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockTr", G->buf+G->pos));
+  return 1;
+  l745:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockTr", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseTr(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseTr"));  if (!yymatchChar(G, '<')) goto l751;  if (!yy_Spnl(G)) { goto l751; }  if (!yymatchChar(G, '/')) goto l751;
+  {  int yypos752= G->pos, yythunkpos752= G->thunkpos;  if (!yymatchString(G, "tr")) goto l753;  goto l752;
+  l753:;	  G->pos= yypos752; G->thunkpos= yythunkpos752;  if (!yymatchString(G, "TR")) goto l751;
+  }
+  l752:;	  if (!yy_Spnl(G)) { goto l751; }  if (!yymatchChar(G, '>')) goto l751;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseTr", G->buf+G->pos));
+  return 1;
+  l751:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseTr", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenTr(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenTr"));  if (!yymatchChar(G, '<')) goto l754;  if (!yy_Spnl(G)) { goto l754; }
+  {  int yypos755= G->pos, yythunkpos755= G->thunkpos;  if (!yymatchString(G, "tr")) goto l756;  goto l755;
+  l756:;	  G->pos= yypos755; G->thunkpos= yythunkpos755;  if (!yymatchString(G, "TR")) goto l754;
+  }
+  l755:;	  if (!yy_Spnl(G)) { goto l754; }
+  l757:;	
+  {  int yypos758= G->pos, yythunkpos758= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l758; }  goto l757;
+  l758:;	  G->pos= yypos758; G->thunkpos= yythunkpos758;
+  }  if (!yymatchChar(G, '>')) goto l754;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenTr", G->buf+G->pos));
+  return 1;
+  l754:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenTr", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockThead(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockThead"));  if (!yy_HtmlBlockOpenThead(G)) { goto l759; }
+  l760:;	
+  {  int yypos761= G->pos, yythunkpos761= G->thunkpos;
+  {  int yypos762= G->pos, yythunkpos762= G->thunkpos;  if (!yy_HtmlBlockThead(G)) { goto l763; }  goto l762;
+  l763:;	  G->pos= yypos762; G->thunkpos= yythunkpos762;
+  {  int yypos764= G->pos, yythunkpos764= G->thunkpos;  if (!yy_HtmlBlockCloseThead(G)) { goto l764; }  goto l761;
+  l764:;	  G->pos= yypos764; G->thunkpos= yythunkpos764;
+  }  if (!yymatchDot(G)) goto l761;
+  }
+  l762:;	  goto l760;
+  l761:;	  G->pos= yypos761; G->thunkpos= yythunkpos761;
+  }  if (!yy_HtmlBlockCloseThead(G)) { goto l759; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockThead", G->buf+G->pos));
+  return 1;
+  l759:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockThead", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseThead(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseThead"));  if (!yymatchChar(G, '<')) goto l765;  if (!yy_Spnl(G)) { goto l765; }  if (!yymatchChar(G, '/')) goto l765;
+  {  int yypos766= G->pos, yythunkpos766= G->thunkpos;  if (!yymatchString(G, "thead")) goto l767;  goto l766;
+  l767:;	  G->pos= yypos766; G->thunkpos= yythunkpos766;  if (!yymatchString(G, "THEAD")) goto l765;
+  }
+  l766:;	  if (!yy_Spnl(G)) { goto l765; }  if (!yymatchChar(G, '>')) goto l765;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseThead", G->buf+G->pos));
+  return 1;
+  l765:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseThead", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenThead(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenThead"));  if (!yymatchChar(G, '<')) goto l768;  if (!yy_Spnl(G)) { goto l768; }
+  {  int yypos769= G->pos, yythunkpos769= G->thunkpos;  if (!yymatchString(G, "thead")) goto l770;  goto l769;
+  l770:;	  G->pos= yypos769; G->thunkpos= yythunkpos769;  if (!yymatchString(G, "THEAD")) goto l768;
+  }
+  l769:;	  if (!yy_Spnl(G)) { goto l768; }
+  l771:;	
+  {  int yypos772= G->pos, yythunkpos772= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l772; }  goto l771;
+  l772:;	  G->pos= yypos772; G->thunkpos= yythunkpos772;
+  }  if (!yymatchChar(G, '>')) goto l768;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenThead", G->buf+G->pos));
+  return 1;
+  l768:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenThead", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockTh(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockTh"));  if (!yy_HtmlBlockOpenTh(G)) { goto l773; }
+  l774:;	
+  {  int yypos775= G->pos, yythunkpos775= G->thunkpos;
+  {  int yypos776= G->pos, yythunkpos776= G->thunkpos;  if (!yy_HtmlBlockTh(G)) { goto l777; }  goto l776;
+  l777:;	  G->pos= yypos776; G->thunkpos= yythunkpos776;
+  {  int yypos778= G->pos, yythunkpos778= G->thunkpos;  if (!yy_HtmlBlockCloseTh(G)) { goto l778; }  goto l775;
+  l778:;	  G->pos= yypos778; G->thunkpos= yythunkpos778;
+  }  if (!yymatchDot(G)) goto l775;
+  }
+  l776:;	  goto l774;
+  l775:;	  G->pos= yypos775; G->thunkpos= yythunkpos775;
+  }  if (!yy_HtmlBlockCloseTh(G)) { goto l773; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockTh", G->buf+G->pos));
+  return 1;
+  l773:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockTh", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseTh(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseTh"));  if (!yymatchChar(G, '<')) goto l779;  if (!yy_Spnl(G)) { goto l779; }  if (!yymatchChar(G, '/')) goto l779;
+  {  int yypos780= G->pos, yythunkpos780= G->thunkpos;  if (!yymatchString(G, "th")) goto l781;  goto l780;
+  l781:;	  G->pos= yypos780; G->thunkpos= yythunkpos780;  if (!yymatchString(G, "TH")) goto l779;
+  }
+  l780:;	  if (!yy_Spnl(G)) { goto l779; }  if (!yymatchChar(G, '>')) goto l779;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseTh", G->buf+G->pos));
+  return 1;
+  l779:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseTh", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenTh(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenTh"));  if (!yymatchChar(G, '<')) goto l782;  if (!yy_Spnl(G)) { goto l782; }
+  {  int yypos783= G->pos, yythunkpos783= G->thunkpos;  if (!yymatchString(G, "th")) goto l784;  goto l783;
+  l784:;	  G->pos= yypos783; G->thunkpos= yythunkpos783;  if (!yymatchString(G, "TH")) goto l782;
+  }
+  l783:;	  if (!yy_Spnl(G)) { goto l782; }
+  l785:;	
+  {  int yypos786= G->pos, yythunkpos786= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l786; }  goto l785;
+  l786:;	  G->pos= yypos786; G->thunkpos= yythunkpos786;
+  }  if (!yymatchChar(G, '>')) goto l782;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenTh", G->buf+G->pos));
+  return 1;
+  l782:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenTh", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockTfoot(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockTfoot"));  if (!yy_HtmlBlockOpenTfoot(G)) { goto l787; }
+  l788:;	
+  {  int yypos789= G->pos, yythunkpos789= G->thunkpos;
+  {  int yypos790= G->pos, yythunkpos790= G->thunkpos;  if (!yy_HtmlBlockTfoot(G)) { goto l791; }  goto l790;
+  l791:;	  G->pos= yypos790; G->thunkpos= yythunkpos790;
+  {  int yypos792= G->pos, yythunkpos792= G->thunkpos;  if (!yy_HtmlBlockCloseTfoot(G)) { goto l792; }  goto l789;
+  l792:;	  G->pos= yypos792; G->thunkpos= yythunkpos792;
+  }  if (!yymatchDot(G)) goto l789;
+  }
+  l790:;	  goto l788;
+  l789:;	  G->pos= yypos789; G->thunkpos= yythunkpos789;
+  }  if (!yy_HtmlBlockCloseTfoot(G)) { goto l787; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockTfoot", G->buf+G->pos));
+  return 1;
+  l787:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockTfoot", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseTfoot(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseTfoot"));  if (!yymatchChar(G, '<')) goto l793;  if (!yy_Spnl(G)) { goto l793; }  if (!yymatchChar(G, '/')) goto l793;
+  {  int yypos794= G->pos, yythunkpos794= G->thunkpos;  if (!yymatchString(G, "tfoot")) goto l795;  goto l794;
+  l795:;	  G->pos= yypos794; G->thunkpos= yythunkpos794;  if (!yymatchString(G, "TFOOT")) goto l793;
+  }
+  l794:;	  if (!yy_Spnl(G)) { goto l793; }  if (!yymatchChar(G, '>')) goto l793;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseTfoot", G->buf+G->pos));
+  return 1;
+  l793:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseTfoot", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenTfoot(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenTfoot"));  if (!yymatchChar(G, '<')) goto l796;  if (!yy_Spnl(G)) { goto l796; }
+  {  int yypos797= G->pos, yythunkpos797= G->thunkpos;  if (!yymatchString(G, "tfoot")) goto l798;  goto l797;
+  l798:;	  G->pos= yypos797; G->thunkpos= yythunkpos797;  if (!yymatchString(G, "TFOOT")) goto l796;
+  }
+  l797:;	  if (!yy_Spnl(G)) { goto l796; }
+  l799:;	
+  {  int yypos800= G->pos, yythunkpos800= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l800; }  goto l799;
+  l800:;	  G->pos= yypos800; G->thunkpos= yythunkpos800;
+  }  if (!yymatchChar(G, '>')) goto l796;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenTfoot", G->buf+G->pos));
+  return 1;
+  l796:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenTfoot", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockTd(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockTd"));  if (!yy_HtmlBlockOpenTd(G)) { goto l801; }
+  l802:;	
+  {  int yypos803= G->pos, yythunkpos803= G->thunkpos;
+  {  int yypos804= G->pos, yythunkpos804= G->thunkpos;  if (!yy_HtmlBlockTd(G)) { goto l805; }  goto l804;
+  l805:;	  G->pos= yypos804; G->thunkpos= yythunkpos804;
+  {  int yypos806= G->pos, yythunkpos806= G->thunkpos;  if (!yy_HtmlBlockCloseTd(G)) { goto l806; }  goto l803;
+  l806:;	  G->pos= yypos806; G->thunkpos= yythunkpos806;
+  }  if (!yymatchDot(G)) goto l803;
+  }
+  l804:;	  goto l802;
+  l803:;	  G->pos= yypos803; G->thunkpos= yythunkpos803;
+  }  if (!yy_HtmlBlockCloseTd(G)) { goto l801; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockTd", G->buf+G->pos));
+  return 1;
+  l801:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockTd", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseTd(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseTd"));  if (!yymatchChar(G, '<')) goto l807;  if (!yy_Spnl(G)) { goto l807; }  if (!yymatchChar(G, '/')) goto l807;
+  {  int yypos808= G->pos, yythunkpos808= G->thunkpos;  if (!yymatchString(G, "td")) goto l809;  goto l808;
+  l809:;	  G->pos= yypos808; G->thunkpos= yythunkpos808;  if (!yymatchString(G, "TD")) goto l807;
+  }
+  l808:;	  if (!yy_Spnl(G)) { goto l807; }  if (!yymatchChar(G, '>')) goto l807;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseTd", G->buf+G->pos));
+  return 1;
+  l807:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseTd", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenTd(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenTd"));  if (!yymatchChar(G, '<')) goto l810;  if (!yy_Spnl(G)) { goto l810; }
+  {  int yypos811= G->pos, yythunkpos811= G->thunkpos;  if (!yymatchString(G, "td")) goto l812;  goto l811;
+  l812:;	  G->pos= yypos811; G->thunkpos= yythunkpos811;  if (!yymatchString(G, "TD")) goto l810;
+  }
+  l811:;	  if (!yy_Spnl(G)) { goto l810; }
+  l813:;	
+  {  int yypos814= G->pos, yythunkpos814= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l814; }  goto l813;
+  l814:;	  G->pos= yypos814; G->thunkpos= yythunkpos814;
+  }  if (!yymatchChar(G, '>')) goto l810;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenTd", G->buf+G->pos));
+  return 1;
+  l810:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenTd", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockTbody(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockTbody"));  if (!yy_HtmlBlockOpenTbody(G)) { goto l815; }
+  l816:;	
+  {  int yypos817= G->pos, yythunkpos817= G->thunkpos;
+  {  int yypos818= G->pos, yythunkpos818= G->thunkpos;  if (!yy_HtmlBlockTbody(G)) { goto l819; }  goto l818;
+  l819:;	  G->pos= yypos818; G->thunkpos= yythunkpos818;
+  {  int yypos820= G->pos, yythunkpos820= G->thunkpos;  if (!yy_HtmlBlockCloseTbody(G)) { goto l820; }  goto l817;
+  l820:;	  G->pos= yypos820; G->thunkpos= yythunkpos820;
+  }  if (!yymatchDot(G)) goto l817;
+  }
+  l818:;	  goto l816;
+  l817:;	  G->pos= yypos817; G->thunkpos= yythunkpos817;
+  }  if (!yy_HtmlBlockCloseTbody(G)) { goto l815; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockTbody", G->buf+G->pos));
+  return 1;
+  l815:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockTbody", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseTbody(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseTbody"));  if (!yymatchChar(G, '<')) goto l821;  if (!yy_Spnl(G)) { goto l821; }  if (!yymatchChar(G, '/')) goto l821;
+  {  int yypos822= G->pos, yythunkpos822= G->thunkpos;  if (!yymatchString(G, "tbody")) goto l823;  goto l822;
+  l823:;	  G->pos= yypos822; G->thunkpos= yythunkpos822;  if (!yymatchString(G, "TBODY")) goto l821;
+  }
+  l822:;	  if (!yy_Spnl(G)) { goto l821; }  if (!yymatchChar(G, '>')) goto l821;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseTbody", G->buf+G->pos));
+  return 1;
+  l821:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseTbody", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenTbody(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenTbody"));  if (!yymatchChar(G, '<')) goto l824;  if (!yy_Spnl(G)) { goto l824; }
+  {  int yypos825= G->pos, yythunkpos825= G->thunkpos;  if (!yymatchString(G, "tbody")) goto l826;  goto l825;
+  l826:;	  G->pos= yypos825; G->thunkpos= yythunkpos825;  if (!yymatchString(G, "TBODY")) goto l824;
+  }
+  l825:;	  if (!yy_Spnl(G)) { goto l824; }
+  l827:;	
+  {  int yypos828= G->pos, yythunkpos828= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l828; }  goto l827;
+  l828:;	  G->pos= yypos828; G->thunkpos= yythunkpos828;
+  }  if (!yymatchChar(G, '>')) goto l824;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenTbody", G->buf+G->pos));
+  return 1;
+  l824:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenTbody", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockLi(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockLi"));  if (!yy_HtmlBlockOpenLi(G)) { goto l829; }
+  l830:;	
+  {  int yypos831= G->pos, yythunkpos831= G->thunkpos;
+  {  int yypos832= G->pos, yythunkpos832= G->thunkpos;  if (!yy_HtmlBlockLi(G)) { goto l833; }  goto l832;
+  l833:;	  G->pos= yypos832; G->thunkpos= yythunkpos832;
+  {  int yypos834= G->pos, yythunkpos834= G->thunkpos;  if (!yy_HtmlBlockCloseLi(G)) { goto l834; }  goto l831;
+  l834:;	  G->pos= yypos834; G->thunkpos= yythunkpos834;
+  }  if (!yymatchDot(G)) goto l831;
+  }
+  l832:;	  goto l830;
+  l831:;	  G->pos= yypos831; G->thunkpos= yythunkpos831;
+  }  if (!yy_HtmlBlockCloseLi(G)) { goto l829; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockLi", G->buf+G->pos));
+  return 1;
+  l829:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockLi", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseLi(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseLi"));  if (!yymatchChar(G, '<')) goto l835;  if (!yy_Spnl(G)) { goto l835; }  if (!yymatchChar(G, '/')) goto l835;
+  {  int yypos836= G->pos, yythunkpos836= G->thunkpos;  if (!yymatchString(G, "li")) goto l837;  goto l836;
+  l837:;	  G->pos= yypos836; G->thunkpos= yythunkpos836;  if (!yymatchString(G, "LI")) goto l835;
+  }
+  l836:;	  if (!yy_Spnl(G)) { goto l835; }  if (!yymatchChar(G, '>')) goto l835;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseLi", G->buf+G->pos));
+  return 1;
+  l835:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseLi", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenLi(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenLi"));  if (!yymatchChar(G, '<')) goto l838;  if (!yy_Spnl(G)) { goto l838; }
+  {  int yypos839= G->pos, yythunkpos839= G->thunkpos;  if (!yymatchString(G, "li")) goto l840;  goto l839;
+  l840:;	  G->pos= yypos839; G->thunkpos= yythunkpos839;  if (!yymatchString(G, "LI")) goto l838;
+  }
+  l839:;	  if (!yy_Spnl(G)) { goto l838; }
+  l841:;	
+  {  int yypos842= G->pos, yythunkpos842= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l842; }  goto l841;
+  l842:;	  G->pos= yypos842; G->thunkpos= yythunkpos842;
+  }  if (!yymatchChar(G, '>')) goto l838;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenLi", G->buf+G->pos));
+  return 1;
+  l838:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenLi", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockFrameset(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockFrameset"));  if (!yy_HtmlBlockOpenFrameset(G)) { goto l843; }
+  l844:;	
+  {  int yypos845= G->pos, yythunkpos845= G->thunkpos;
+  {  int yypos846= G->pos, yythunkpos846= G->thunkpos;  if (!yy_HtmlBlockFrameset(G)) { goto l847; }  goto l846;
+  l847:;	  G->pos= yypos846; G->thunkpos= yythunkpos846;
+  {  int yypos848= G->pos, yythunkpos848= G->thunkpos;  if (!yy_HtmlBlockCloseFrameset(G)) { goto l848; }  goto l845;
+  l848:;	  G->pos= yypos848; G->thunkpos= yythunkpos848;
+  }  if (!yymatchDot(G)) goto l845;
+  }
+  l846:;	  goto l844;
+  l845:;	  G->pos= yypos845; G->thunkpos= yythunkpos845;
+  }  if (!yy_HtmlBlockCloseFrameset(G)) { goto l843; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockFrameset", G->buf+G->pos));
+  return 1;
+  l843:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockFrameset", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseFrameset(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseFrameset"));  if (!yymatchChar(G, '<')) goto l849;  if (!yy_Spnl(G)) { goto l849; }  if (!yymatchChar(G, '/')) goto l849;
+  {  int yypos850= G->pos, yythunkpos850= G->thunkpos;  if (!yymatchString(G, "frameset")) goto l851;  goto l850;
+  l851:;	  G->pos= yypos850; G->thunkpos= yythunkpos850;  if (!yymatchString(G, "FRAMESET")) goto l849;
+  }
+  l850:;	  if (!yy_Spnl(G)) { goto l849; }  if (!yymatchChar(G, '>')) goto l849;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseFrameset", G->buf+G->pos));
+  return 1;
+  l849:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseFrameset", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenFrameset(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenFrameset"));  if (!yymatchChar(G, '<')) goto l852;  if (!yy_Spnl(G)) { goto l852; }
+  {  int yypos853= G->pos, yythunkpos853= G->thunkpos;  if (!yymatchString(G, "frameset")) goto l854;  goto l853;
+  l854:;	  G->pos= yypos853; G->thunkpos= yythunkpos853;  if (!yymatchString(G, "FRAMESET")) goto l852;
+  }
+  l853:;	  if (!yy_Spnl(G)) { goto l852; }
+  l855:;	
+  {  int yypos856= G->pos, yythunkpos856= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l856; }  goto l855;
+  l856:;	  G->pos= yypos856; G->thunkpos= yythunkpos856;
+  }  if (!yymatchChar(G, '>')) goto l852;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenFrameset", G->buf+G->pos));
+  return 1;
+  l852:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenFrameset", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockDt(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockDt"));  if (!yy_HtmlBlockOpenDt(G)) { goto l857; }
+  l858:;	
+  {  int yypos859= G->pos, yythunkpos859= G->thunkpos;
+  {  int yypos860= G->pos, yythunkpos860= G->thunkpos;  if (!yy_HtmlBlockDt(G)) { goto l861; }  goto l860;
+  l861:;	  G->pos= yypos860; G->thunkpos= yythunkpos860;
+  {  int yypos862= G->pos, yythunkpos862= G->thunkpos;  if (!yy_HtmlBlockCloseDt(G)) { goto l862; }  goto l859;
+  l862:;	  G->pos= yypos862; G->thunkpos= yythunkpos862;
+  }  if (!yymatchDot(G)) goto l859;
+  }
+  l860:;	  goto l858;
+  l859:;	  G->pos= yypos859; G->thunkpos= yythunkpos859;
+  }  if (!yy_HtmlBlockCloseDt(G)) { goto l857; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockDt", G->buf+G->pos));
+  return 1;
+  l857:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockDt", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseDt(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseDt"));  if (!yymatchChar(G, '<')) goto l863;  if (!yy_Spnl(G)) { goto l863; }  if (!yymatchChar(G, '/')) goto l863;
+  {  int yypos864= G->pos, yythunkpos864= G->thunkpos;  if (!yymatchString(G, "dt")) goto l865;  goto l864;
+  l865:;	  G->pos= yypos864; G->thunkpos= yythunkpos864;  if (!yymatchString(G, "DT")) goto l863;
+  }
+  l864:;	  if (!yy_Spnl(G)) { goto l863; }  if (!yymatchChar(G, '>')) goto l863;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseDt", G->buf+G->pos));
+  return 1;
+  l863:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseDt", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenDt(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenDt"));  if (!yymatchChar(G, '<')) goto l866;  if (!yy_Spnl(G)) { goto l866; }
+  {  int yypos867= G->pos, yythunkpos867= G->thunkpos;  if (!yymatchString(G, "dt")) goto l868;  goto l867;
+  l868:;	  G->pos= yypos867; G->thunkpos= yythunkpos867;  if (!yymatchString(G, "DT")) goto l866;
+  }
+  l867:;	  if (!yy_Spnl(G)) { goto l866; }
+  l869:;	
+  {  int yypos870= G->pos, yythunkpos870= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l870; }  goto l869;
+  l870:;	  G->pos= yypos870; G->thunkpos= yythunkpos870;
+  }  if (!yymatchChar(G, '>')) goto l866;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenDt", G->buf+G->pos));
+  return 1;
+  l866:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenDt", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockDd(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockDd"));  if (!yy_HtmlBlockOpenDd(G)) { goto l871; }
+  l872:;	
+  {  int yypos873= G->pos, yythunkpos873= G->thunkpos;
+  {  int yypos874= G->pos, yythunkpos874= G->thunkpos;  if (!yy_HtmlBlockDd(G)) { goto l875; }  goto l874;
+  l875:;	  G->pos= yypos874; G->thunkpos= yythunkpos874;
+  {  int yypos876= G->pos, yythunkpos876= G->thunkpos;  if (!yy_HtmlBlockCloseDd(G)) { goto l876; }  goto l873;
+  l876:;	  G->pos= yypos876; G->thunkpos= yythunkpos876;
+  }  if (!yymatchDot(G)) goto l873;
+  }
+  l874:;	  goto l872;
+  l873:;	  G->pos= yypos873; G->thunkpos= yythunkpos873;
+  }  if (!yy_HtmlBlockCloseDd(G)) { goto l871; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockDd", G->buf+G->pos));
+  return 1;
+  l871:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockDd", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseDd(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseDd"));  if (!yymatchChar(G, '<')) goto l877;  if (!yy_Spnl(G)) { goto l877; }  if (!yymatchChar(G, '/')) goto l877;
+  {  int yypos878= G->pos, yythunkpos878= G->thunkpos;  if (!yymatchString(G, "dd")) goto l879;  goto l878;
+  l879:;	  G->pos= yypos878; G->thunkpos= yythunkpos878;  if (!yymatchString(G, "DD")) goto l877;
+  }
+  l878:;	  if (!yy_Spnl(G)) { goto l877; }  if (!yymatchChar(G, '>')) goto l877;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseDd", G->buf+G->pos));
+  return 1;
+  l877:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseDd", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenDd(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenDd"));  if (!yymatchChar(G, '<')) goto l880;  if (!yy_Spnl(G)) { goto l880; }
+  {  int yypos881= G->pos, yythunkpos881= G->thunkpos;  if (!yymatchString(G, "dd")) goto l882;  goto l881;
+  l882:;	  G->pos= yypos881; G->thunkpos= yythunkpos881;  if (!yymatchString(G, "DD")) goto l880;
+  }
+  l881:;	  if (!yy_Spnl(G)) { goto l880; }
+  l883:;	
+  {  int yypos884= G->pos, yythunkpos884= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l884; }  goto l883;
+  l884:;	  G->pos= yypos884; G->thunkpos= yythunkpos884;
+  }  if (!yymatchChar(G, '>')) goto l880;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenDd", G->buf+G->pos));
+  return 1;
+  l880:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenDd", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockUl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockUl"));  if (!yy_HtmlBlockOpenUl(G)) { goto l885; }
+  l886:;	
+  {  int yypos887= G->pos, yythunkpos887= G->thunkpos;
+  {  int yypos888= G->pos, yythunkpos888= G->thunkpos;  if (!yy_HtmlBlockUl(G)) { goto l889; }  goto l888;
+  l889:;	  G->pos= yypos888; G->thunkpos= yythunkpos888;
+  {  int yypos890= G->pos, yythunkpos890= G->thunkpos;  if (!yy_HtmlBlockCloseUl(G)) { goto l890; }  goto l887;
+  l890:;	  G->pos= yypos890; G->thunkpos= yythunkpos890;
+  }  if (!yymatchDot(G)) goto l887;
+  }
+  l888:;	  goto l886;
+  l887:;	  G->pos= yypos887; G->thunkpos= yythunkpos887;
+  }  if (!yy_HtmlBlockCloseUl(G)) { goto l885; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockUl", G->buf+G->pos));
+  return 1;
+  l885:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockUl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseUl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseUl"));  if (!yymatchChar(G, '<')) goto l891;  if (!yy_Spnl(G)) { goto l891; }  if (!yymatchChar(G, '/')) goto l891;
+  {  int yypos892= G->pos, yythunkpos892= G->thunkpos;  if (!yymatchString(G, "ul")) goto l893;  goto l892;
+  l893:;	  G->pos= yypos892; G->thunkpos= yythunkpos892;  if (!yymatchString(G, "UL")) goto l891;
+  }
+  l892:;	  if (!yy_Spnl(G)) { goto l891; }  if (!yymatchChar(G, '>')) goto l891;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseUl", G->buf+G->pos));
+  return 1;
+  l891:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseUl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenUl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenUl"));  if (!yymatchChar(G, '<')) goto l894;  if (!yy_Spnl(G)) { goto l894; }
+  {  int yypos895= G->pos, yythunkpos895= G->thunkpos;  if (!yymatchString(G, "ul")) goto l896;  goto l895;
+  l896:;	  G->pos= yypos895; G->thunkpos= yythunkpos895;  if (!yymatchString(G, "UL")) goto l894;
+  }
+  l895:;	  if (!yy_Spnl(G)) { goto l894; }
+  l897:;	
+  {  int yypos898= G->pos, yythunkpos898= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l898; }  goto l897;
+  l898:;	  G->pos= yypos898; G->thunkpos= yythunkpos898;
+  }  if (!yymatchChar(G, '>')) goto l894;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenUl", G->buf+G->pos));
+  return 1;
+  l894:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenUl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockTable(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockTable"));  if (!yy_HtmlBlockOpenTable(G)) { goto l899; }
+  l900:;	
+  {  int yypos901= G->pos, yythunkpos901= G->thunkpos;
+  {  int yypos902= G->pos, yythunkpos902= G->thunkpos;  if (!yy_HtmlBlockTable(G)) { goto l903; }  goto l902;
+  l903:;	  G->pos= yypos902; G->thunkpos= yythunkpos902;
+  {  int yypos904= G->pos, yythunkpos904= G->thunkpos;  if (!yy_HtmlBlockCloseTable(G)) { goto l904; }  goto l901;
+  l904:;	  G->pos= yypos904; G->thunkpos= yythunkpos904;
+  }  if (!yymatchDot(G)) goto l901;
+  }
+  l902:;	  goto l900;
+  l901:;	  G->pos= yypos901; G->thunkpos= yythunkpos901;
+  }  if (!yy_HtmlBlockCloseTable(G)) { goto l899; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockTable", G->buf+G->pos));
+  return 1;
+  l899:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockTable", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseTable(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseTable"));  if (!yymatchChar(G, '<')) goto l905;  if (!yy_Spnl(G)) { goto l905; }  if (!yymatchChar(G, '/')) goto l905;
+  {  int yypos906= G->pos, yythunkpos906= G->thunkpos;  if (!yymatchString(G, "table")) goto l907;  goto l906;
+  l907:;	  G->pos= yypos906; G->thunkpos= yythunkpos906;  if (!yymatchString(G, "TABLE")) goto l905;
+  }
+  l906:;	  if (!yy_Spnl(G)) { goto l905; }  if (!yymatchChar(G, '>')) goto l905;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseTable", G->buf+G->pos));
+  return 1;
+  l905:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseTable", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenTable(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenTable"));  if (!yymatchChar(G, '<')) goto l908;  if (!yy_Spnl(G)) { goto l908; }
+  {  int yypos909= G->pos, yythunkpos909= G->thunkpos;  if (!yymatchString(G, "table")) goto l910;  goto l909;
+  l910:;	  G->pos= yypos909; G->thunkpos= yythunkpos909;  if (!yymatchString(G, "TABLE")) goto l908;
+  }
+  l909:;	  if (!yy_Spnl(G)) { goto l908; }
+  l911:;	
+  {  int yypos912= G->pos, yythunkpos912= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l912; }  goto l911;
+  l912:;	  G->pos= yypos912; G->thunkpos= yythunkpos912;
+  }  if (!yymatchChar(G, '>')) goto l908;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenTable", G->buf+G->pos));
+  return 1;
+  l908:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenTable", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockPre(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockPre"));  if (!yy_HtmlBlockOpenPre(G)) { goto l913; }
+  l914:;	
+  {  int yypos915= G->pos, yythunkpos915= G->thunkpos;
+  {  int yypos916= G->pos, yythunkpos916= G->thunkpos;  if (!yy_HtmlBlockPre(G)) { goto l917; }  goto l916;
+  l917:;	  G->pos= yypos916; G->thunkpos= yythunkpos916;
+  {  int yypos918= G->pos, yythunkpos918= G->thunkpos;  if (!yy_HtmlBlockClosePre(G)) { goto l918; }  goto l915;
+  l918:;	  G->pos= yypos918; G->thunkpos= yythunkpos918;
+  }  if (!yymatchDot(G)) goto l915;
+  }
+  l916:;	  goto l914;
+  l915:;	  G->pos= yypos915; G->thunkpos= yythunkpos915;
+  }  if (!yy_HtmlBlockClosePre(G)) { goto l913; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockPre", G->buf+G->pos));
+  return 1;
+  l913:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockPre", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockClosePre(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockClosePre"));  if (!yymatchChar(G, '<')) goto l919;  if (!yy_Spnl(G)) { goto l919; }  if (!yymatchChar(G, '/')) goto l919;
+  {  int yypos920= G->pos, yythunkpos920= G->thunkpos;  if (!yymatchString(G, "pre")) goto l921;  goto l920;
+  l921:;	  G->pos= yypos920; G->thunkpos= yythunkpos920;  if (!yymatchString(G, "PRE")) goto l919;
+  }
+  l920:;	  if (!yy_Spnl(G)) { goto l919; }  if (!yymatchChar(G, '>')) goto l919;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockClosePre", G->buf+G->pos));
+  return 1;
+  l919:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockClosePre", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenPre(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenPre"));  if (!yymatchChar(G, '<')) goto l922;  if (!yy_Spnl(G)) { goto l922; }
+  {  int yypos923= G->pos, yythunkpos923= G->thunkpos;  if (!yymatchString(G, "pre")) goto l924;  goto l923;
+  l924:;	  G->pos= yypos923; G->thunkpos= yythunkpos923;  if (!yymatchString(G, "PRE")) goto l922;
+  }
+  l923:;	  if (!yy_Spnl(G)) { goto l922; }
+  l925:;	
+  {  int yypos926= G->pos, yythunkpos926= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l926; }  goto l925;
+  l926:;	  G->pos= yypos926; G->thunkpos= yythunkpos926;
+  }  if (!yymatchChar(G, '>')) goto l922;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenPre", G->buf+G->pos));
+  return 1;
+  l922:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenPre", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockP(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockP"));  if (!yy_HtmlBlockOpenP(G)) { goto l927; }
+  l928:;	
+  {  int yypos929= G->pos, yythunkpos929= G->thunkpos;
+  {  int yypos930= G->pos, yythunkpos930= G->thunkpos;  if (!yy_HtmlBlockP(G)) { goto l931; }  goto l930;
+  l931:;	  G->pos= yypos930; G->thunkpos= yythunkpos930;
+  {  int yypos932= G->pos, yythunkpos932= G->thunkpos;  if (!yy_HtmlBlockCloseP(G)) { goto l932; }  goto l929;
+  l932:;	  G->pos= yypos932; G->thunkpos= yythunkpos932;
+  }  if (!yymatchDot(G)) goto l929;
+  }
+  l930:;	  goto l928;
+  l929:;	  G->pos= yypos929; G->thunkpos= yythunkpos929;
+  }  if (!yy_HtmlBlockCloseP(G)) { goto l927; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockP", G->buf+G->pos));
+  return 1;
+  l927:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockP", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseP(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseP"));  if (!yymatchChar(G, '<')) goto l933;  if (!yy_Spnl(G)) { goto l933; }  if (!yymatchChar(G, '/')) goto l933;
+  {  int yypos934= G->pos, yythunkpos934= G->thunkpos;  if (!yymatchChar(G, 'p')) goto l935;  goto l934;
+  l935:;	  G->pos= yypos934; G->thunkpos= yythunkpos934;  if (!yymatchChar(G, 'P')) goto l933;
+  }
+  l934:;	  if (!yy_Spnl(G)) { goto l933; }  if (!yymatchChar(G, '>')) goto l933;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseP", G->buf+G->pos));
+  return 1;
+  l933:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseP", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenP(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenP"));  if (!yymatchChar(G, '<')) goto l936;  if (!yy_Spnl(G)) { goto l936; }
+  {  int yypos937= G->pos, yythunkpos937= G->thunkpos;  if (!yymatchChar(G, 'p')) goto l938;  goto l937;
+  l938:;	  G->pos= yypos937; G->thunkpos= yythunkpos937;  if (!yymatchChar(G, 'P')) goto l936;
+  }
+  l937:;	  if (!yy_Spnl(G)) { goto l936; }
+  l939:;	
+  {  int yypos940= G->pos, yythunkpos940= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l940; }  goto l939;
+  l940:;	  G->pos= yypos940; G->thunkpos= yythunkpos940;
+  }  if (!yymatchChar(G, '>')) goto l936;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenP", G->buf+G->pos));
+  return 1;
+  l936:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenP", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOl"));  if (!yy_HtmlBlockOpenOl(G)) { goto l941; }
+  l942:;	
+  {  int yypos943= G->pos, yythunkpos943= G->thunkpos;
+  {  int yypos944= G->pos, yythunkpos944= G->thunkpos;  if (!yy_HtmlBlockOl(G)) { goto l945; }  goto l944;
+  l945:;	  G->pos= yypos944; G->thunkpos= yythunkpos944;
+  {  int yypos946= G->pos, yythunkpos946= G->thunkpos;  if (!yy_HtmlBlockCloseOl(G)) { goto l946; }  goto l943;
+  l946:;	  G->pos= yypos946; G->thunkpos= yythunkpos946;
+  }  if (!yymatchDot(G)) goto l943;
+  }
+  l944:;	  goto l942;
+  l943:;	  G->pos= yypos943; G->thunkpos= yythunkpos943;
+  }  if (!yy_HtmlBlockCloseOl(G)) { goto l941; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOl", G->buf+G->pos));
+  return 1;
+  l941:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseOl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseOl"));  if (!yymatchChar(G, '<')) goto l947;  if (!yy_Spnl(G)) { goto l947; }  if (!yymatchChar(G, '/')) goto l947;
+  {  int yypos948= G->pos, yythunkpos948= G->thunkpos;  if (!yymatchString(G, "ol")) goto l949;  goto l948;
+  l949:;	  G->pos= yypos948; G->thunkpos= yythunkpos948;  if (!yymatchString(G, "OL")) goto l947;
+  }
+  l948:;	  if (!yy_Spnl(G)) { goto l947; }  if (!yymatchChar(G, '>')) goto l947;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseOl", G->buf+G->pos));
+  return 1;
+  l947:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseOl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenOl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenOl"));  if (!yymatchChar(G, '<')) goto l950;  if (!yy_Spnl(G)) { goto l950; }
+  {  int yypos951= G->pos, yythunkpos951= G->thunkpos;  if (!yymatchString(G, "ol")) goto l952;  goto l951;
+  l952:;	  G->pos= yypos951; G->thunkpos= yythunkpos951;  if (!yymatchString(G, "OL")) goto l950;
+  }
+  l951:;	  if (!yy_Spnl(G)) { goto l950; }
+  l953:;	
+  {  int yypos954= G->pos, yythunkpos954= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l954; }  goto l953;
+  l954:;	  G->pos= yypos954; G->thunkpos= yythunkpos954;
+  }  if (!yymatchChar(G, '>')) goto l950;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenOl", G->buf+G->pos));
+  return 1;
+  l950:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenOl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockNoscript(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockNoscript"));  if (!yy_HtmlBlockOpenNoscript(G)) { goto l955; }
+  l956:;	
+  {  int yypos957= G->pos, yythunkpos957= G->thunkpos;
+  {  int yypos958= G->pos, yythunkpos958= G->thunkpos;  if (!yy_HtmlBlockNoscript(G)) { goto l959; }  goto l958;
+  l959:;	  G->pos= yypos958; G->thunkpos= yythunkpos958;
+  {  int yypos960= G->pos, yythunkpos960= G->thunkpos;  if (!yy_HtmlBlockCloseNoscript(G)) { goto l960; }  goto l957;
+  l960:;	  G->pos= yypos960; G->thunkpos= yythunkpos960;
+  }  if (!yymatchDot(G)) goto l957;
+  }
+  l958:;	  goto l956;
+  l957:;	  G->pos= yypos957; G->thunkpos= yythunkpos957;
+  }  if (!yy_HtmlBlockCloseNoscript(G)) { goto l955; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockNoscript", G->buf+G->pos));
+  return 1;
+  l955:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockNoscript", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseNoscript(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseNoscript"));  if (!yymatchChar(G, '<')) goto l961;  if (!yy_Spnl(G)) { goto l961; }  if (!yymatchChar(G, '/')) goto l961;
+  {  int yypos962= G->pos, yythunkpos962= G->thunkpos;  if (!yymatchString(G, "noscript")) goto l963;  goto l962;
+  l963:;	  G->pos= yypos962; G->thunkpos= yythunkpos962;  if (!yymatchString(G, "NOSCRIPT")) goto l961;
+  }
+  l962:;	  if (!yy_Spnl(G)) { goto l961; }  if (!yymatchChar(G, '>')) goto l961;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseNoscript", G->buf+G->pos));
+  return 1;
+  l961:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseNoscript", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenNoscript(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenNoscript"));  if (!yymatchChar(G, '<')) goto l964;  if (!yy_Spnl(G)) { goto l964; }
+  {  int yypos965= G->pos, yythunkpos965= G->thunkpos;  if (!yymatchString(G, "noscript")) goto l966;  goto l965;
+  l966:;	  G->pos= yypos965; G->thunkpos= yythunkpos965;  if (!yymatchString(G, "NOSCRIPT")) goto l964;
+  }
+  l965:;	  if (!yy_Spnl(G)) { goto l964; }
+  l967:;	
+  {  int yypos968= G->pos, yythunkpos968= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l968; }  goto l967;
+  l968:;	  G->pos= yypos968; G->thunkpos= yythunkpos968;
+  }  if (!yymatchChar(G, '>')) goto l964;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenNoscript", G->buf+G->pos));
+  return 1;
+  l964:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenNoscript", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockNoframes(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockNoframes"));  if (!yy_HtmlBlockOpenNoframes(G)) { goto l969; }
+  l970:;	
+  {  int yypos971= G->pos, yythunkpos971= G->thunkpos;
+  {  int yypos972= G->pos, yythunkpos972= G->thunkpos;  if (!yy_HtmlBlockNoframes(G)) { goto l973; }  goto l972;
+  l973:;	  G->pos= yypos972; G->thunkpos= yythunkpos972;
+  {  int yypos974= G->pos, yythunkpos974= G->thunkpos;  if (!yy_HtmlBlockCloseNoframes(G)) { goto l974; }  goto l971;
+  l974:;	  G->pos= yypos974; G->thunkpos= yythunkpos974;
+  }  if (!yymatchDot(G)) goto l971;
+  }
+  l972:;	  goto l970;
+  l971:;	  G->pos= yypos971; G->thunkpos= yythunkpos971;
+  }  if (!yy_HtmlBlockCloseNoframes(G)) { goto l969; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockNoframes", G->buf+G->pos));
+  return 1;
+  l969:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockNoframes", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseNoframes(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseNoframes"));  if (!yymatchChar(G, '<')) goto l975;  if (!yy_Spnl(G)) { goto l975; }  if (!yymatchChar(G, '/')) goto l975;
+  {  int yypos976= G->pos, yythunkpos976= G->thunkpos;  if (!yymatchString(G, "noframes")) goto l977;  goto l976;
+  l977:;	  G->pos= yypos976; G->thunkpos= yythunkpos976;  if (!yymatchString(G, "NOFRAMES")) goto l975;
+  }
+  l976:;	  if (!yy_Spnl(G)) { goto l975; }  if (!yymatchChar(G, '>')) goto l975;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseNoframes", G->buf+G->pos));
+  return 1;
+  l975:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseNoframes", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenNoframes(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenNoframes"));  if (!yymatchChar(G, '<')) goto l978;  if (!yy_Spnl(G)) { goto l978; }
+  {  int yypos979= G->pos, yythunkpos979= G->thunkpos;  if (!yymatchString(G, "noframes")) goto l980;  goto l979;
+  l980:;	  G->pos= yypos979; G->thunkpos= yythunkpos979;  if (!yymatchString(G, "NOFRAMES")) goto l978;
+  }
+  l979:;	  if (!yy_Spnl(G)) { goto l978; }
+  l981:;	
+  {  int yypos982= G->pos, yythunkpos982= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l982; }  goto l981;
+  l982:;	  G->pos= yypos982; G->thunkpos= yythunkpos982;
+  }  if (!yymatchChar(G, '>')) goto l978;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenNoframes", G->buf+G->pos));
+  return 1;
+  l978:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenNoframes", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockMenu(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockMenu"));  if (!yy_HtmlBlockOpenMenu(G)) { goto l983; }
+  l984:;	
+  {  int yypos985= G->pos, yythunkpos985= G->thunkpos;
+  {  int yypos986= G->pos, yythunkpos986= G->thunkpos;  if (!yy_HtmlBlockMenu(G)) { goto l987; }  goto l986;
+  l987:;	  G->pos= yypos986; G->thunkpos= yythunkpos986;
+  {  int yypos988= G->pos, yythunkpos988= G->thunkpos;  if (!yy_HtmlBlockCloseMenu(G)) { goto l988; }  goto l985;
+  l988:;	  G->pos= yypos988; G->thunkpos= yythunkpos988;
+  }  if (!yymatchDot(G)) goto l985;
+  }
+  l986:;	  goto l984;
+  l985:;	  G->pos= yypos985; G->thunkpos= yythunkpos985;
+  }  if (!yy_HtmlBlockCloseMenu(G)) { goto l983; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockMenu", G->buf+G->pos));
+  return 1;
+  l983:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockMenu", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseMenu(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseMenu"));  if (!yymatchChar(G, '<')) goto l989;  if (!yy_Spnl(G)) { goto l989; }  if (!yymatchChar(G, '/')) goto l989;
+  {  int yypos990= G->pos, yythunkpos990= G->thunkpos;  if (!yymatchString(G, "menu")) goto l991;  goto l990;
+  l991:;	  G->pos= yypos990; G->thunkpos= yythunkpos990;  if (!yymatchString(G, "MENU")) goto l989;
+  }
+  l990:;	  if (!yy_Spnl(G)) { goto l989; }  if (!yymatchChar(G, '>')) goto l989;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseMenu", G->buf+G->pos));
+  return 1;
+  l989:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseMenu", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenMenu(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenMenu"));  if (!yymatchChar(G, '<')) goto l992;  if (!yy_Spnl(G)) { goto l992; }
+  {  int yypos993= G->pos, yythunkpos993= G->thunkpos;  if (!yymatchString(G, "menu")) goto l994;  goto l993;
+  l994:;	  G->pos= yypos993; G->thunkpos= yythunkpos993;  if (!yymatchString(G, "MENU")) goto l992;
+  }
+  l993:;	  if (!yy_Spnl(G)) { goto l992; }
+  l995:;	
+  {  int yypos996= G->pos, yythunkpos996= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l996; }  goto l995;
+  l996:;	  G->pos= yypos996; G->thunkpos= yythunkpos996;
+  }  if (!yymatchChar(G, '>')) goto l992;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenMenu", G->buf+G->pos));
+  return 1;
+  l992:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenMenu", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockH6(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlBlockH6"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l997;  if (!yy_LocMarker(G)) { goto l997; }  yyDo(G, yySet, -1, 0);  if (!yy_HtmlBlockOpenH6(G)) { goto l997; }
+  l998:;	
+  {  int yypos999= G->pos, yythunkpos999= G->thunkpos;
+  {  int yypos1000= G->pos, yythunkpos1000= G->thunkpos;  if (!yy_HtmlBlockH6(G)) { goto l1001; }  goto l1000;
+  l1001:;	  G->pos= yypos1000; G->thunkpos= yythunkpos1000;
+  {  int yypos1002= G->pos, yythunkpos1002= G->thunkpos;  if (!yy_HtmlBlockCloseH6(G)) { goto l1002; }  goto l999;
+  l1002:;	  G->pos= yypos1002; G->thunkpos= yythunkpos1002;
+  }  if (!yymatchDot(G)) goto l999;
+  }
+  l1000:;	  goto l998;
+  l999:;	  G->pos= yypos999; G->thunkpos= yythunkpos999;
+  }  if (!yy_HtmlBlockCloseH6(G)) { goto l997; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l997;  yyDo(G, yy_1_HtmlBlockH6, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockH6", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l997:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockH6", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseH6(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseH6"));  if (!yymatchChar(G, '<')) goto l1003;  if (!yy_Spnl(G)) { goto l1003; }  if (!yymatchChar(G, '/')) goto l1003;
+  {  int yypos1004= G->pos, yythunkpos1004= G->thunkpos;  if (!yymatchString(G, "h6")) goto l1005;  goto l1004;
+  l1005:;	  G->pos= yypos1004; G->thunkpos= yythunkpos1004;  if (!yymatchString(G, "H6")) goto l1003;
+  }
+  l1004:;	  if (!yy_Spnl(G)) { goto l1003; }  if (!yymatchChar(G, '>')) goto l1003;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseH6", G->buf+G->pos));
+  return 1;
+  l1003:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseH6", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenH6(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenH6"));  if (!yymatchChar(G, '<')) goto l1006;  if (!yy_Spnl(G)) { goto l1006; }
+  {  int yypos1007= G->pos, yythunkpos1007= G->thunkpos;  if (!yymatchString(G, "h6")) goto l1008;  goto l1007;
+  l1008:;	  G->pos= yypos1007; G->thunkpos= yythunkpos1007;  if (!yymatchString(G, "H6")) goto l1006;
+  }
+  l1007:;	  if (!yy_Spnl(G)) { goto l1006; }
+  l1009:;	
+  {  int yypos1010= G->pos, yythunkpos1010= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1010; }  goto l1009;
+  l1010:;	  G->pos= yypos1010; G->thunkpos= yythunkpos1010;
+  }  if (!yymatchChar(G, '>')) goto l1006;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenH6", G->buf+G->pos));
+  return 1;
+  l1006:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenH6", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockH5(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlBlockH5"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1011;  if (!yy_LocMarker(G)) { goto l1011; }  yyDo(G, yySet, -1, 0);  if (!yy_HtmlBlockOpenH5(G)) { goto l1011; }
+  l1012:;	
+  {  int yypos1013= G->pos, yythunkpos1013= G->thunkpos;
+  {  int yypos1014= G->pos, yythunkpos1014= G->thunkpos;  if (!yy_HtmlBlockH5(G)) { goto l1015; }  goto l1014;
+  l1015:;	  G->pos= yypos1014; G->thunkpos= yythunkpos1014;
+  {  int yypos1016= G->pos, yythunkpos1016= G->thunkpos;  if (!yy_HtmlBlockCloseH5(G)) { goto l1016; }  goto l1013;
+  l1016:;	  G->pos= yypos1016; G->thunkpos= yythunkpos1016;
+  }  if (!yymatchDot(G)) goto l1013;
+  }
+  l1014:;	  goto l1012;
+  l1013:;	  G->pos= yypos1013; G->thunkpos= yythunkpos1013;
+  }  if (!yy_HtmlBlockCloseH5(G)) { goto l1011; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1011;  yyDo(G, yy_1_HtmlBlockH5, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockH5", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1011:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockH5", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseH5(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseH5"));  if (!yymatchChar(G, '<')) goto l1017;  if (!yy_Spnl(G)) { goto l1017; }  if (!yymatchChar(G, '/')) goto l1017;
+  {  int yypos1018= G->pos, yythunkpos1018= G->thunkpos;  if (!yymatchString(G, "h5")) goto l1019;  goto l1018;
+  l1019:;	  G->pos= yypos1018; G->thunkpos= yythunkpos1018;  if (!yymatchString(G, "H5")) goto l1017;
+  }
+  l1018:;	  if (!yy_Spnl(G)) { goto l1017; }  if (!yymatchChar(G, '>')) goto l1017;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseH5", G->buf+G->pos));
+  return 1;
+  l1017:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseH5", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenH5(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenH5"));  if (!yymatchChar(G, '<')) goto l1020;  if (!yy_Spnl(G)) { goto l1020; }
+  {  int yypos1021= G->pos, yythunkpos1021= G->thunkpos;  if (!yymatchString(G, "h5")) goto l1022;  goto l1021;
+  l1022:;	  G->pos= yypos1021; G->thunkpos= yythunkpos1021;  if (!yymatchString(G, "H5")) goto l1020;
+  }
+  l1021:;	  if (!yy_Spnl(G)) { goto l1020; }
+  l1023:;	
+  {  int yypos1024= G->pos, yythunkpos1024= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1024; }  goto l1023;
+  l1024:;	  G->pos= yypos1024; G->thunkpos= yythunkpos1024;
+  }  if (!yymatchChar(G, '>')) goto l1020;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenH5", G->buf+G->pos));
+  return 1;
+  l1020:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenH5", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockH4(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlBlockH4"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1025;  if (!yy_LocMarker(G)) { goto l1025; }  yyDo(G, yySet, -1, 0);  if (!yy_HtmlBlockOpenH4(G)) { goto l1025; }
+  l1026:;	
+  {  int yypos1027= G->pos, yythunkpos1027= G->thunkpos;
+  {  int yypos1028= G->pos, yythunkpos1028= G->thunkpos;  if (!yy_HtmlBlockH4(G)) { goto l1029; }  goto l1028;
+  l1029:;	  G->pos= yypos1028; G->thunkpos= yythunkpos1028;
+  {  int yypos1030= G->pos, yythunkpos1030= G->thunkpos;  if (!yy_HtmlBlockCloseH4(G)) { goto l1030; }  goto l1027;
+  l1030:;	  G->pos= yypos1030; G->thunkpos= yythunkpos1030;
+  }  if (!yymatchDot(G)) goto l1027;
+  }
+  l1028:;	  goto l1026;
+  l1027:;	  G->pos= yypos1027; G->thunkpos= yythunkpos1027;
+  }  if (!yy_HtmlBlockCloseH4(G)) { goto l1025; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1025;  yyDo(G, yy_1_HtmlBlockH4, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockH4", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1025:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockH4", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseH4(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseH4"));  if (!yymatchChar(G, '<')) goto l1031;  if (!yy_Spnl(G)) { goto l1031; }  if (!yymatchChar(G, '/')) goto l1031;
+  {  int yypos1032= G->pos, yythunkpos1032= G->thunkpos;  if (!yymatchString(G, "h4")) goto l1033;  goto l1032;
+  l1033:;	  G->pos= yypos1032; G->thunkpos= yythunkpos1032;  if (!yymatchString(G, "H4")) goto l1031;
+  }
+  l1032:;	  if (!yy_Spnl(G)) { goto l1031; }  if (!yymatchChar(G, '>')) goto l1031;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseH4", G->buf+G->pos));
+  return 1;
+  l1031:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseH4", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenH4(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenH4"));  if (!yymatchChar(G, '<')) goto l1034;  if (!yy_Spnl(G)) { goto l1034; }
+  {  int yypos1035= G->pos, yythunkpos1035= G->thunkpos;  if (!yymatchString(G, "h4")) goto l1036;  goto l1035;
+  l1036:;	  G->pos= yypos1035; G->thunkpos= yythunkpos1035;  if (!yymatchString(G, "H4")) goto l1034;
+  }
+  l1035:;	  if (!yy_Spnl(G)) { goto l1034; }
+  l1037:;	
+  {  int yypos1038= G->pos, yythunkpos1038= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1038; }  goto l1037;
+  l1038:;	  G->pos= yypos1038; G->thunkpos= yythunkpos1038;
+  }  if (!yymatchChar(G, '>')) goto l1034;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenH4", G->buf+G->pos));
+  return 1;
+  l1034:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenH4", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockH3(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlBlockH3"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1039;  if (!yy_LocMarker(G)) { goto l1039; }  yyDo(G, yySet, -1, 0);  if (!yy_HtmlBlockOpenH3(G)) { goto l1039; }
+  l1040:;	
+  {  int yypos1041= G->pos, yythunkpos1041= G->thunkpos;
+  {  int yypos1042= G->pos, yythunkpos1042= G->thunkpos;  if (!yy_HtmlBlockH3(G)) { goto l1043; }  goto l1042;
+  l1043:;	  G->pos= yypos1042; G->thunkpos= yythunkpos1042;
+  {  int yypos1044= G->pos, yythunkpos1044= G->thunkpos;  if (!yy_HtmlBlockCloseH3(G)) { goto l1044; }  goto l1041;
+  l1044:;	  G->pos= yypos1044; G->thunkpos= yythunkpos1044;
+  }  if (!yymatchDot(G)) goto l1041;
+  }
+  l1042:;	  goto l1040;
+  l1041:;	  G->pos= yypos1041; G->thunkpos= yythunkpos1041;
+  }  if (!yy_HtmlBlockCloseH3(G)) { goto l1039; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1039;  yyDo(G, yy_1_HtmlBlockH3, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockH3", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1039:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockH3", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseH3(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseH3"));  if (!yymatchChar(G, '<')) goto l1045;  if (!yy_Spnl(G)) { goto l1045; }  if (!yymatchChar(G, '/')) goto l1045;
+  {  int yypos1046= G->pos, yythunkpos1046= G->thunkpos;  if (!yymatchString(G, "h3")) goto l1047;  goto l1046;
+  l1047:;	  G->pos= yypos1046; G->thunkpos= yythunkpos1046;  if (!yymatchString(G, "H3")) goto l1045;
+  }
+  l1046:;	  if (!yy_Spnl(G)) { goto l1045; }  if (!yymatchChar(G, '>')) goto l1045;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseH3", G->buf+G->pos));
+  return 1;
+  l1045:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseH3", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenH3(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenH3"));  if (!yymatchChar(G, '<')) goto l1048;  if (!yy_Spnl(G)) { goto l1048; }
+  {  int yypos1049= G->pos, yythunkpos1049= G->thunkpos;  if (!yymatchString(G, "h3")) goto l1050;  goto l1049;
+  l1050:;	  G->pos= yypos1049; G->thunkpos= yythunkpos1049;  if (!yymatchString(G, "H3")) goto l1048;
+  }
+  l1049:;	  if (!yy_Spnl(G)) { goto l1048; }
+  l1051:;	
+  {  int yypos1052= G->pos, yythunkpos1052= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1052; }  goto l1051;
+  l1052:;	  G->pos= yypos1052; G->thunkpos= yythunkpos1052;
+  }  if (!yymatchChar(G, '>')) goto l1048;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenH3", G->buf+G->pos));
+  return 1;
+  l1048:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenH3", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockH2(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlBlockH2"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1053;  if (!yy_LocMarker(G)) { goto l1053; }  yyDo(G, yySet, -1, 0);  if (!yy_HtmlBlockOpenH2(G)) { goto l1053; }
+  l1054:;	
+  {  int yypos1055= G->pos, yythunkpos1055= G->thunkpos;
+  {  int yypos1056= G->pos, yythunkpos1056= G->thunkpos;  if (!yy_HtmlBlockH2(G)) { goto l1057; }  goto l1056;
+  l1057:;	  G->pos= yypos1056; G->thunkpos= yythunkpos1056;
+  {  int yypos1058= G->pos, yythunkpos1058= G->thunkpos;  if (!yy_HtmlBlockCloseH2(G)) { goto l1058; }  goto l1055;
+  l1058:;	  G->pos= yypos1058; G->thunkpos= yythunkpos1058;
+  }  if (!yymatchDot(G)) goto l1055;
+  }
+  l1056:;	  goto l1054;
+  l1055:;	  G->pos= yypos1055; G->thunkpos= yythunkpos1055;
+  }  if (!yy_HtmlBlockCloseH2(G)) { goto l1053; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1053;  yyDo(G, yy_1_HtmlBlockH2, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockH2", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1053:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockH2", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseH2(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseH2"));  if (!yymatchChar(G, '<')) goto l1059;  if (!yy_Spnl(G)) { goto l1059; }  if (!yymatchChar(G, '/')) goto l1059;
+  {  int yypos1060= G->pos, yythunkpos1060= G->thunkpos;  if (!yymatchString(G, "h2")) goto l1061;  goto l1060;
+  l1061:;	  G->pos= yypos1060; G->thunkpos= yythunkpos1060;  if (!yymatchString(G, "H2")) goto l1059;
+  }
+  l1060:;	  if (!yy_Spnl(G)) { goto l1059; }  if (!yymatchChar(G, '>')) goto l1059;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseH2", G->buf+G->pos));
+  return 1;
+  l1059:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseH2", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenH2(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenH2"));  if (!yymatchChar(G, '<')) goto l1062;  if (!yy_Spnl(G)) { goto l1062; }
+  {  int yypos1063= G->pos, yythunkpos1063= G->thunkpos;  if (!yymatchString(G, "h2")) goto l1064;  goto l1063;
+  l1064:;	  G->pos= yypos1063; G->thunkpos= yythunkpos1063;  if (!yymatchString(G, "H2")) goto l1062;
+  }
+  l1063:;	  if (!yy_Spnl(G)) { goto l1062; }
+  l1065:;	
+  {  int yypos1066= G->pos, yythunkpos1066= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1066; }  goto l1065;
+  l1066:;	  G->pos= yypos1066; G->thunkpos= yythunkpos1066;
+  }  if (!yymatchChar(G, '>')) goto l1062;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenH2", G->buf+G->pos));
+  return 1;
+  l1062:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenH2", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockH1(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlBlockH1"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1067;  if (!yy_LocMarker(G)) { goto l1067; }  yyDo(G, yySet, -1, 0);  if (!yy_HtmlBlockOpenH1(G)) { goto l1067; }
+  l1068:;	
+  {  int yypos1069= G->pos, yythunkpos1069= G->thunkpos;
+  {  int yypos1070= G->pos, yythunkpos1070= G->thunkpos;  if (!yy_HtmlBlockH1(G)) { goto l1071; }  goto l1070;
+  l1071:;	  G->pos= yypos1070; G->thunkpos= yythunkpos1070;
+  {  int yypos1072= G->pos, yythunkpos1072= G->thunkpos;  if (!yy_HtmlBlockCloseH1(G)) { goto l1072; }  goto l1069;
+  l1072:;	  G->pos= yypos1072; G->thunkpos= yythunkpos1072;
+  }  if (!yymatchDot(G)) goto l1069;
+  }
+  l1070:;	  goto l1068;
+  l1069:;	  G->pos= yypos1069; G->thunkpos= yythunkpos1069;
+  }  if (!yy_HtmlBlockCloseH1(G)) { goto l1067; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1067;  yyDo(G, yy_1_HtmlBlockH1, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockH1", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1067:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockH1", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseH1(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseH1"));  if (!yymatchChar(G, '<')) goto l1073;  if (!yy_Spnl(G)) { goto l1073; }  if (!yymatchChar(G, '/')) goto l1073;
+  {  int yypos1074= G->pos, yythunkpos1074= G->thunkpos;  if (!yymatchString(G, "h1")) goto l1075;  goto l1074;
+  l1075:;	  G->pos= yypos1074; G->thunkpos= yythunkpos1074;  if (!yymatchString(G, "H1")) goto l1073;
+  }
+  l1074:;	  if (!yy_Spnl(G)) { goto l1073; }  if (!yymatchChar(G, '>')) goto l1073;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseH1", G->buf+G->pos));
+  return 1;
+  l1073:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseH1", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenH1(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenH1"));  if (!yymatchChar(G, '<')) goto l1076;  if (!yy_Spnl(G)) { goto l1076; }
+  {  int yypos1077= G->pos, yythunkpos1077= G->thunkpos;  if (!yymatchString(G, "h1")) goto l1078;  goto l1077;
+  l1078:;	  G->pos= yypos1077; G->thunkpos= yythunkpos1077;  if (!yymatchString(G, "H1")) goto l1076;
+  }
+  l1077:;	  if (!yy_Spnl(G)) { goto l1076; }
+  l1079:;	
+  {  int yypos1080= G->pos, yythunkpos1080= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1080; }  goto l1079;
+  l1080:;	  G->pos= yypos1080; G->thunkpos= yythunkpos1080;
+  }  if (!yymatchChar(G, '>')) goto l1076;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenH1", G->buf+G->pos));
+  return 1;
+  l1076:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenH1", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockForm(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockForm"));  if (!yy_HtmlBlockOpenForm(G)) { goto l1081; }
+  l1082:;	
+  {  int yypos1083= G->pos, yythunkpos1083= G->thunkpos;
+  {  int yypos1084= G->pos, yythunkpos1084= G->thunkpos;  if (!yy_HtmlBlockForm(G)) { goto l1085; }  goto l1084;
+  l1085:;	  G->pos= yypos1084; G->thunkpos= yythunkpos1084;
+  {  int yypos1086= G->pos, yythunkpos1086= G->thunkpos;  if (!yy_HtmlBlockCloseForm(G)) { goto l1086; }  goto l1083;
+  l1086:;	  G->pos= yypos1086; G->thunkpos= yythunkpos1086;
+  }  if (!yymatchDot(G)) goto l1083;
+  }
+  l1084:;	  goto l1082;
+  l1083:;	  G->pos= yypos1083; G->thunkpos= yythunkpos1083;
+  }  if (!yy_HtmlBlockCloseForm(G)) { goto l1081; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockForm", G->buf+G->pos));
+  return 1;
+  l1081:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockForm", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseForm(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseForm"));  if (!yymatchChar(G, '<')) goto l1087;  if (!yy_Spnl(G)) { goto l1087; }  if (!yymatchChar(G, '/')) goto l1087;
+  {  int yypos1088= G->pos, yythunkpos1088= G->thunkpos;  if (!yymatchString(G, "form")) goto l1089;  goto l1088;
+  l1089:;	  G->pos= yypos1088; G->thunkpos= yythunkpos1088;  if (!yymatchString(G, "FORM")) goto l1087;
+  }
+  l1088:;	  if (!yy_Spnl(G)) { goto l1087; }  if (!yymatchChar(G, '>')) goto l1087;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseForm", G->buf+G->pos));
+  return 1;
+  l1087:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseForm", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenForm(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenForm"));  if (!yymatchChar(G, '<')) goto l1090;  if (!yy_Spnl(G)) { goto l1090; }
+  {  int yypos1091= G->pos, yythunkpos1091= G->thunkpos;  if (!yymatchString(G, "form")) goto l1092;  goto l1091;
+  l1092:;	  G->pos= yypos1091; G->thunkpos= yythunkpos1091;  if (!yymatchString(G, "FORM")) goto l1090;
+  }
+  l1091:;	  if (!yy_Spnl(G)) { goto l1090; }
+  l1093:;	
+  {  int yypos1094= G->pos, yythunkpos1094= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1094; }  goto l1093;
+  l1094:;	  G->pos= yypos1094; G->thunkpos= yythunkpos1094;
+  }  if (!yymatchChar(G, '>')) goto l1090;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenForm", G->buf+G->pos));
+  return 1;
+  l1090:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenForm", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockFieldset(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockFieldset"));  if (!yy_HtmlBlockOpenFieldset(G)) { goto l1095; }
+  l1096:;	
+  {  int yypos1097= G->pos, yythunkpos1097= G->thunkpos;
+  {  int yypos1098= G->pos, yythunkpos1098= G->thunkpos;  if (!yy_HtmlBlockFieldset(G)) { goto l1099; }  goto l1098;
+  l1099:;	  G->pos= yypos1098; G->thunkpos= yythunkpos1098;
+  {  int yypos1100= G->pos, yythunkpos1100= G->thunkpos;  if (!yy_HtmlBlockCloseFieldset(G)) { goto l1100; }  goto l1097;
+  l1100:;	  G->pos= yypos1100; G->thunkpos= yythunkpos1100;
+  }  if (!yymatchDot(G)) goto l1097;
+  }
+  l1098:;	  goto l1096;
+  l1097:;	  G->pos= yypos1097; G->thunkpos= yythunkpos1097;
+  }  if (!yy_HtmlBlockCloseFieldset(G)) { goto l1095; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockFieldset", G->buf+G->pos));
+  return 1;
+  l1095:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockFieldset", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseFieldset(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseFieldset"));  if (!yymatchChar(G, '<')) goto l1101;  if (!yy_Spnl(G)) { goto l1101; }  if (!yymatchChar(G, '/')) goto l1101;
+  {  int yypos1102= G->pos, yythunkpos1102= G->thunkpos;  if (!yymatchString(G, "fieldset")) goto l1103;  goto l1102;
+  l1103:;	  G->pos= yypos1102; G->thunkpos= yythunkpos1102;  if (!yymatchString(G, "FIELDSET")) goto l1101;
+  }
+  l1102:;	  if (!yy_Spnl(G)) { goto l1101; }  if (!yymatchChar(G, '>')) goto l1101;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseFieldset", G->buf+G->pos));
+  return 1;
+  l1101:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseFieldset", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenFieldset(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenFieldset"));  if (!yymatchChar(G, '<')) goto l1104;  if (!yy_Spnl(G)) { goto l1104; }
+  {  int yypos1105= G->pos, yythunkpos1105= G->thunkpos;  if (!yymatchString(G, "fieldset")) goto l1106;  goto l1105;
+  l1106:;	  G->pos= yypos1105; G->thunkpos= yythunkpos1105;  if (!yymatchString(G, "FIELDSET")) goto l1104;
+  }
+  l1105:;	  if (!yy_Spnl(G)) { goto l1104; }
+  l1107:;	
+  {  int yypos1108= G->pos, yythunkpos1108= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1108; }  goto l1107;
+  l1108:;	  G->pos= yypos1108; G->thunkpos= yythunkpos1108;
+  }  if (!yymatchChar(G, '>')) goto l1104;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenFieldset", G->buf+G->pos));
+  return 1;
+  l1104:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenFieldset", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockDl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockDl"));  if (!yy_HtmlBlockOpenDl(G)) { goto l1109; }
+  l1110:;	
+  {  int yypos1111= G->pos, yythunkpos1111= G->thunkpos;
+  {  int yypos1112= G->pos, yythunkpos1112= G->thunkpos;  if (!yy_HtmlBlockDl(G)) { goto l1113; }  goto l1112;
+  l1113:;	  G->pos= yypos1112; G->thunkpos= yythunkpos1112;
+  {  int yypos1114= G->pos, yythunkpos1114= G->thunkpos;  if (!yy_HtmlBlockCloseDl(G)) { goto l1114; }  goto l1111;
+  l1114:;	  G->pos= yypos1114; G->thunkpos= yythunkpos1114;
+  }  if (!yymatchDot(G)) goto l1111;
+  }
+  l1112:;	  goto l1110;
+  l1111:;	  G->pos= yypos1111; G->thunkpos= yythunkpos1111;
+  }  if (!yy_HtmlBlockCloseDl(G)) { goto l1109; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockDl", G->buf+G->pos));
+  return 1;
+  l1109:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockDl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseDl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseDl"));  if (!yymatchChar(G, '<')) goto l1115;  if (!yy_Spnl(G)) { goto l1115; }  if (!yymatchChar(G, '/')) goto l1115;
+  {  int yypos1116= G->pos, yythunkpos1116= G->thunkpos;  if (!yymatchString(G, "dl")) goto l1117;  goto l1116;
+  l1117:;	  G->pos= yypos1116; G->thunkpos= yythunkpos1116;  if (!yymatchString(G, "DL")) goto l1115;
+  }
+  l1116:;	  if (!yy_Spnl(G)) { goto l1115; }  if (!yymatchChar(G, '>')) goto l1115;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseDl", G->buf+G->pos));
+  return 1;
+  l1115:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseDl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenDl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenDl"));  if (!yymatchChar(G, '<')) goto l1118;  if (!yy_Spnl(G)) { goto l1118; }
+  {  int yypos1119= G->pos, yythunkpos1119= G->thunkpos;  if (!yymatchString(G, "dl")) goto l1120;  goto l1119;
+  l1120:;	  G->pos= yypos1119; G->thunkpos= yythunkpos1119;  if (!yymatchString(G, "DL")) goto l1118;
+  }
+  l1119:;	  if (!yy_Spnl(G)) { goto l1118; }
+  l1121:;	
+  {  int yypos1122= G->pos, yythunkpos1122= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1122; }  goto l1121;
+  l1122:;	  G->pos= yypos1122; G->thunkpos= yythunkpos1122;
+  }  if (!yymatchChar(G, '>')) goto l1118;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenDl", G->buf+G->pos));
+  return 1;
+  l1118:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenDl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockDiv(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockDiv"));  if (!yy_HtmlBlockOpenDiv(G)) { goto l1123; }
+  l1124:;	
+  {  int yypos1125= G->pos, yythunkpos1125= G->thunkpos;
+  {  int yypos1126= G->pos, yythunkpos1126= G->thunkpos;  if (!yy_HtmlBlockDiv(G)) { goto l1127; }  goto l1126;
+  l1127:;	  G->pos= yypos1126; G->thunkpos= yythunkpos1126;
+  {  int yypos1128= G->pos, yythunkpos1128= G->thunkpos;  if (!yy_HtmlBlockCloseDiv(G)) { goto l1128; }  goto l1125;
+  l1128:;	  G->pos= yypos1128; G->thunkpos= yythunkpos1128;
+  }  if (!yymatchDot(G)) goto l1125;
+  }
+  l1126:;	  goto l1124;
+  l1125:;	  G->pos= yypos1125; G->thunkpos= yythunkpos1125;
+  }  if (!yy_HtmlBlockCloseDiv(G)) { goto l1123; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockDiv", G->buf+G->pos));
+  return 1;
+  l1123:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockDiv", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseDiv(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseDiv"));  if (!yymatchChar(G, '<')) goto l1129;  if (!yy_Spnl(G)) { goto l1129; }  if (!yymatchChar(G, '/')) goto l1129;
+  {  int yypos1130= G->pos, yythunkpos1130= G->thunkpos;  if (!yymatchString(G, "div")) goto l1131;  goto l1130;
+  l1131:;	  G->pos= yypos1130; G->thunkpos= yythunkpos1130;  if (!yymatchString(G, "DIV")) goto l1129;
+  }
+  l1130:;	  if (!yy_Spnl(G)) { goto l1129; }  if (!yymatchChar(G, '>')) goto l1129;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseDiv", G->buf+G->pos));
+  return 1;
+  l1129:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseDiv", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenDiv(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenDiv"));  if (!yymatchChar(G, '<')) goto l1132;  if (!yy_Spnl(G)) { goto l1132; }
+  {  int yypos1133= G->pos, yythunkpos1133= G->thunkpos;  if (!yymatchString(G, "div")) goto l1134;  goto l1133;
+  l1134:;	  G->pos= yypos1133; G->thunkpos= yythunkpos1133;  if (!yymatchString(G, "DIV")) goto l1132;
+  }
+  l1133:;	  if (!yy_Spnl(G)) { goto l1132; }
+  l1135:;	
+  {  int yypos1136= G->pos, yythunkpos1136= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1136; }  goto l1135;
+  l1136:;	  G->pos= yypos1136; G->thunkpos= yythunkpos1136;
+  }  if (!yymatchChar(G, '>')) goto l1132;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenDiv", G->buf+G->pos));
+  return 1;
+  l1132:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenDiv", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockDir(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockDir"));  if (!yy_HtmlBlockOpenDir(G)) { goto l1137; }
+  l1138:;	
+  {  int yypos1139= G->pos, yythunkpos1139= G->thunkpos;
+  {  int yypos1140= G->pos, yythunkpos1140= G->thunkpos;  if (!yy_HtmlBlockDir(G)) { goto l1141; }  goto l1140;
+  l1141:;	  G->pos= yypos1140; G->thunkpos= yythunkpos1140;
+  {  int yypos1142= G->pos, yythunkpos1142= G->thunkpos;  if (!yy_HtmlBlockCloseDir(G)) { goto l1142; }  goto l1139;
+  l1142:;	  G->pos= yypos1142; G->thunkpos= yythunkpos1142;
+  }  if (!yymatchDot(G)) goto l1139;
+  }
+  l1140:;	  goto l1138;
+  l1139:;	  G->pos= yypos1139; G->thunkpos= yythunkpos1139;
+  }  if (!yy_HtmlBlockCloseDir(G)) { goto l1137; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockDir", G->buf+G->pos));
+  return 1;
+  l1137:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockDir", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseDir(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseDir"));  if (!yymatchChar(G, '<')) goto l1143;  if (!yy_Spnl(G)) { goto l1143; }  if (!yymatchChar(G, '/')) goto l1143;
+  {  int yypos1144= G->pos, yythunkpos1144= G->thunkpos;  if (!yymatchString(G, "dir")) goto l1145;  goto l1144;
+  l1145:;	  G->pos= yypos1144; G->thunkpos= yythunkpos1144;  if (!yymatchString(G, "DIR")) goto l1143;
+  }
+  l1144:;	  if (!yy_Spnl(G)) { goto l1143; }  if (!yymatchChar(G, '>')) goto l1143;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseDir", G->buf+G->pos));
+  return 1;
+  l1143:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseDir", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenDir(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenDir"));  if (!yymatchChar(G, '<')) goto l1146;  if (!yy_Spnl(G)) { goto l1146; }
+  {  int yypos1147= G->pos, yythunkpos1147= G->thunkpos;  if (!yymatchString(G, "dir")) goto l1148;  goto l1147;
+  l1148:;	  G->pos= yypos1147; G->thunkpos= yythunkpos1147;  if (!yymatchString(G, "DIR")) goto l1146;
+  }
+  l1147:;	  if (!yy_Spnl(G)) { goto l1146; }
+  l1149:;	
+  {  int yypos1150= G->pos, yythunkpos1150= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1150; }  goto l1149;
+  l1150:;	  G->pos= yypos1150; G->thunkpos= yythunkpos1150;
+  }  if (!yymatchChar(G, '>')) goto l1146;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenDir", G->buf+G->pos));
+  return 1;
+  l1146:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenDir", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCenter(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCenter"));  if (!yy_HtmlBlockOpenCenter(G)) { goto l1151; }
+  l1152:;	
+  {  int yypos1153= G->pos, yythunkpos1153= G->thunkpos;
+  {  int yypos1154= G->pos, yythunkpos1154= G->thunkpos;  if (!yy_HtmlBlockCenter(G)) { goto l1155; }  goto l1154;
+  l1155:;	  G->pos= yypos1154; G->thunkpos= yythunkpos1154;
+  {  int yypos1156= G->pos, yythunkpos1156= G->thunkpos;  if (!yy_HtmlBlockCloseCenter(G)) { goto l1156; }  goto l1153;
+  l1156:;	  G->pos= yypos1156; G->thunkpos= yythunkpos1156;
+  }  if (!yymatchDot(G)) goto l1153;
+  }
+  l1154:;	  goto l1152;
+  l1153:;	  G->pos= yypos1153; G->thunkpos= yythunkpos1153;
+  }  if (!yy_HtmlBlockCloseCenter(G)) { goto l1151; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCenter", G->buf+G->pos));
+  return 1;
+  l1151:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCenter", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseCenter(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseCenter"));  if (!yymatchChar(G, '<')) goto l1157;  if (!yy_Spnl(G)) { goto l1157; }  if (!yymatchChar(G, '/')) goto l1157;
+  {  int yypos1158= G->pos, yythunkpos1158= G->thunkpos;  if (!yymatchString(G, "center")) goto l1159;  goto l1158;
+  l1159:;	  G->pos= yypos1158; G->thunkpos= yythunkpos1158;  if (!yymatchString(G, "CENTER")) goto l1157;
+  }
+  l1158:;	  if (!yy_Spnl(G)) { goto l1157; }  if (!yymatchChar(G, '>')) goto l1157;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseCenter", G->buf+G->pos));
+  return 1;
+  l1157:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseCenter", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenCenter(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenCenter"));  if (!yymatchChar(G, '<')) goto l1160;  if (!yy_Spnl(G)) { goto l1160; }
+  {  int yypos1161= G->pos, yythunkpos1161= G->thunkpos;  if (!yymatchString(G, "center")) goto l1162;  goto l1161;
+  l1162:;	  G->pos= yypos1161; G->thunkpos= yythunkpos1161;  if (!yymatchString(G, "CENTER")) goto l1160;
+  }
+  l1161:;	  if (!yy_Spnl(G)) { goto l1160; }
+  l1163:;	
+  {  int yypos1164= G->pos, yythunkpos1164= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1164; }  goto l1163;
+  l1164:;	  G->pos= yypos1164; G->thunkpos= yythunkpos1164;
+  }  if (!yymatchChar(G, '>')) goto l1160;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenCenter", G->buf+G->pos));
+  return 1;
+  l1160:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenCenter", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockBlockquote(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockBlockquote"));  if (!yy_HtmlBlockOpenBlockquote(G)) { goto l1165; }
+  l1166:;	
+  {  int yypos1167= G->pos, yythunkpos1167= G->thunkpos;
+  {  int yypos1168= G->pos, yythunkpos1168= G->thunkpos;  if (!yy_HtmlBlockBlockquote(G)) { goto l1169; }  goto l1168;
+  l1169:;	  G->pos= yypos1168; G->thunkpos= yythunkpos1168;
+  {  int yypos1170= G->pos, yythunkpos1170= G->thunkpos;  if (!yy_HtmlBlockCloseBlockquote(G)) { goto l1170; }  goto l1167;
+  l1170:;	  G->pos= yypos1170; G->thunkpos= yythunkpos1170;
+  }  if (!yymatchDot(G)) goto l1167;
+  }
+  l1168:;	  goto l1166;
+  l1167:;	  G->pos= yypos1167; G->thunkpos= yythunkpos1167;
+  }  if (!yy_HtmlBlockCloseBlockquote(G)) { goto l1165; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockBlockquote", G->buf+G->pos));
+  return 1;
+  l1165:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockBlockquote", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseBlockquote(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseBlockquote"));  if (!yymatchChar(G, '<')) goto l1171;  if (!yy_Spnl(G)) { goto l1171; }  if (!yymatchChar(G, '/')) goto l1171;
+  {  int yypos1172= G->pos, yythunkpos1172= G->thunkpos;  if (!yymatchString(G, "blockquote")) goto l1173;  goto l1172;
+  l1173:;	  G->pos= yypos1172; G->thunkpos= yythunkpos1172;  if (!yymatchString(G, "BLOCKQUOTE")) goto l1171;
+  }
+  l1172:;	  if (!yy_Spnl(G)) { goto l1171; }  if (!yymatchChar(G, '>')) goto l1171;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseBlockquote", G->buf+G->pos));
+  return 1;
+  l1171:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseBlockquote", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenBlockquote(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenBlockquote"));  if (!yymatchChar(G, '<')) goto l1174;  if (!yy_Spnl(G)) { goto l1174; }
+  {  int yypos1175= G->pos, yythunkpos1175= G->thunkpos;  if (!yymatchString(G, "blockquote")) goto l1176;  goto l1175;
+  l1176:;	  G->pos= yypos1175; G->thunkpos= yythunkpos1175;  if (!yymatchString(G, "BLOCKQUOTE")) goto l1174;
+  }
+  l1175:;	  if (!yy_Spnl(G)) { goto l1174; }
+  l1177:;	
+  {  int yypos1178= G->pos, yythunkpos1178= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1178; }  goto l1177;
+  l1178:;	  G->pos= yypos1178; G->thunkpos= yythunkpos1178;
+  }  if (!yymatchChar(G, '>')) goto l1174;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenBlockquote", G->buf+G->pos));
+  return 1;
+  l1174:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenBlockquote", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockAddress(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockAddress"));  if (!yy_HtmlBlockOpenAddress(G)) { goto l1179; }
+  l1180:;	
+  {  int yypos1181= G->pos, yythunkpos1181= G->thunkpos;
+  {  int yypos1182= G->pos, yythunkpos1182= G->thunkpos;  if (!yy_HtmlBlockAddress(G)) { goto l1183; }  goto l1182;
+  l1183:;	  G->pos= yypos1182; G->thunkpos= yythunkpos1182;
+  {  int yypos1184= G->pos, yythunkpos1184= G->thunkpos;  if (!yy_HtmlBlockCloseAddress(G)) { goto l1184; }  goto l1181;
+  l1184:;	  G->pos= yypos1184; G->thunkpos= yythunkpos1184;
+  }  if (!yymatchDot(G)) goto l1181;
+  }
+  l1182:;	  goto l1180;
+  l1181:;	  G->pos= yypos1181; G->thunkpos= yythunkpos1181;
+  }  if (!yy_HtmlBlockCloseAddress(G)) { goto l1179; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockAddress", G->buf+G->pos));
+  return 1;
+  l1179:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockAddress", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockCloseAddress(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockCloseAddress"));  if (!yymatchChar(G, '<')) goto l1185;  if (!yy_Spnl(G)) { goto l1185; }  if (!yymatchChar(G, '/')) goto l1185;
+  {  int yypos1186= G->pos, yythunkpos1186= G->thunkpos;  if (!yymatchString(G, "address")) goto l1187;  goto l1186;
+  l1187:;	  G->pos= yypos1186; G->thunkpos= yythunkpos1186;  if (!yymatchString(G, "ADDRESS")) goto l1185;
+  }
+  l1186:;	  if (!yy_Spnl(G)) { goto l1185; }  if (!yymatchChar(G, '>')) goto l1185;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockCloseAddress", G->buf+G->pos));
+  return 1;
+  l1185:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockCloseAddress", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlAttribute(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlAttribute"));
+  {  int yypos1191= G->pos, yythunkpos1191= G->thunkpos;  if (!yy_AlphanumericAscii(G)) { goto l1192; }  goto l1191;
+  l1192:;	  G->pos= yypos1191; G->thunkpos= yythunkpos1191;  if (!yymatchChar(G, '-')) goto l1188;
+  }
+  l1191:;	
+  l1189:;	
+  {  int yypos1190= G->pos, yythunkpos1190= G->thunkpos;
+  {  int yypos1193= G->pos, yythunkpos1193= G->thunkpos;  if (!yy_AlphanumericAscii(G)) { goto l1194; }  goto l1193;
+  l1194:;	  G->pos= yypos1193; G->thunkpos= yythunkpos1193;  if (!yymatchChar(G, '-')) goto l1190;
+  }
+  l1193:;	  goto l1189;
+  l1190:;	  G->pos= yypos1190; G->thunkpos= yythunkpos1190;
+  }  if (!yy_Spnl(G)) { goto l1188; }
+  {  int yypos1195= G->pos, yythunkpos1195= G->thunkpos;  if (!yymatchChar(G, '=')) goto l1195;  if (!yy_Spnl(G)) { goto l1195; }
+  {  int yypos1197= G->pos, yythunkpos1197= G->thunkpos;  if (!yy_Quoted(G)) { goto l1198; }  goto l1197;
+  l1198:;	  G->pos= yypos1197; G->thunkpos= yythunkpos1197;
+  {  int yypos1201= G->pos, yythunkpos1201= G->thunkpos;  if (!yymatchChar(G, '>')) goto l1201;  goto l1195;
+  l1201:;	  G->pos= yypos1201; G->thunkpos= yythunkpos1201;
+  }  if (!yy_Nonspacechar(G)) { goto l1195; }
+  l1199:;	
+  {  int yypos1200= G->pos, yythunkpos1200= G->thunkpos;
+  {  int yypos1202= G->pos, yythunkpos1202= G->thunkpos;  if (!yymatchChar(G, '>')) goto l1202;  goto l1200;
+  l1202:;	  G->pos= yypos1202; G->thunkpos= yythunkpos1202;
+  }  if (!yy_Nonspacechar(G)) { goto l1200; }  goto l1199;
+  l1200:;	  G->pos= yypos1200; G->thunkpos= yythunkpos1200;
+  }
+  }
+  l1197:;	  goto l1196;
+  l1195:;	  G->pos= yypos1195; G->thunkpos= yythunkpos1195;
+  }
+  l1196:;	  if (!yy_Spnl(G)) { goto l1188; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlAttribute", G->buf+G->pos));
+  return 1;
+  l1188:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlAttribute", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Spnl(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Spnl"));  if (!yy_Sp(G)) { goto l1203; }
+  {  int yypos1204= G->pos, yythunkpos1204= G->thunkpos;  if (!yy_Newline(G)) { goto l1204; }  if (!yy_Sp(G)) { goto l1204; }  goto l1205;
+  l1204:;	  G->pos= yypos1204; G->thunkpos= yythunkpos1204;
+  }
+  l1205:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Spnl", G->buf+G->pos));
+  return 1;
+  l1203:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Spnl", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlockOpenAddress(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HtmlBlockOpenAddress"));  if (!yymatchChar(G, '<')) goto l1206;  if (!yy_Spnl(G)) { goto l1206; }
+  {  int yypos1207= G->pos, yythunkpos1207= G->thunkpos;  if (!yymatchString(G, "address")) goto l1208;  goto l1207;
+  l1208:;	  G->pos= yypos1207; G->thunkpos= yythunkpos1207;  if (!yymatchString(G, "ADDRESS")) goto l1206;
+  }
+  l1207:;	  if (!yy_Spnl(G)) { goto l1206; }
+  l1209:;	
+  {  int yypos1210= G->pos, yythunkpos1210= G->thunkpos;  if (!yy_HtmlAttribute(G)) { goto l1210; }  goto l1209;
+  l1210:;	  G->pos= yypos1210; G->thunkpos= yythunkpos1210;
+  }  if (!yymatchChar(G, '>')) goto l1206;
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlockOpenAddress", G->buf+G->pos));
+  return 1;
+  l1206:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlockOpenAddress", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_OptionallyIndentedLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "OptionallyIndentedLine"));
+  {  int yypos1212= G->pos, yythunkpos1212= G->thunkpos;  if (!yy_Indent(G)) { goto l1212; }  goto l1213;
+  l1212:;	  G->pos= yypos1212; G->thunkpos= yythunkpos1212;
+  }
+  l1213:;	  if (!yy_Line(G)) { goto l1211; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "OptionallyIndentedLine", G->buf+G->pos));
+  return 1;
+  l1211:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "OptionallyIndentedLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Indent(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Indent"));
+  {  int yypos1215= G->pos, yythunkpos1215= G->thunkpos;  if (!yymatchChar(G, '\t')) goto l1216;  goto l1215;
+  l1216:;	  G->pos= yypos1215; G->thunkpos= yythunkpos1215;  if (!yymatchString(G, "    ")) goto l1214;
+  }
+  l1215:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Indent", G->buf+G->pos));
+  return 1;
+  l1214:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Indent", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ListBlockLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "ListBlockLine"));
+  {  int yypos1218= G->pos, yythunkpos1218= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1218; }  goto l1217;
+  l1218:;	  G->pos= yypos1218; G->thunkpos= yythunkpos1218;
+  }
+  {  int yypos1219= G->pos, yythunkpos1219= G->thunkpos;
+  {  int yypos1220= G->pos, yythunkpos1220= G->thunkpos;  if (!yy_Indent(G)) { goto l1220; }  goto l1221;
+  l1220:;	  G->pos= yypos1220; G->thunkpos= yythunkpos1220;
+  }
+  l1221:;	
+  {  int yypos1222= G->pos, yythunkpos1222= G->thunkpos;  if (!yy_Bullet(G)) { goto l1223; }  goto l1222;
+  l1223:;	  G->pos= yypos1222; G->thunkpos= yythunkpos1222;  if (!yy_Enumerator(G)) { goto l1219; }
+  }
+  l1222:;	  goto l1217;
+  l1219:;	  G->pos= yypos1219; G->thunkpos= yythunkpos1219;
+  }
+  {  int yypos1224= G->pos, yythunkpos1224= G->thunkpos;  if (!yy_HorizontalRule(G)) { goto l1224; }  goto l1217;
+  l1224:;	  G->pos= yypos1224; G->thunkpos= yythunkpos1224;
+  }  if (!yy_OptionallyIndentedLine(G)) { goto l1217; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "ListBlockLine", G->buf+G->pos));
+  return 1;
+  l1217:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ListBlockLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ListContinuationBlock(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "ListContinuationBlock"));  if (!yy_StartList(G)) { goto l1225; }  yyDo(G, yySet, -1, 0);  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1225;
+  l1226:;	
+  {  int yypos1227= G->pos, yythunkpos1227= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1227; }  goto l1226;
+  l1227:;	  G->pos= yypos1227; G->thunkpos= yythunkpos1227;
+  }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1225;  yyDo(G, yy_1_ListContinuationBlock, G->begin, G->end);  if (!yy_Indent(G)) { goto l1225; }  if (!yy_ListBlock(G)) { goto l1225; }  yyDo(G, yy_2_ListContinuationBlock, G->begin, G->end);
+  l1228:;	
+  {  int yypos1229= G->pos, yythunkpos1229= G->thunkpos;  if (!yy_Indent(G)) { goto l1229; }  if (!yy_ListBlock(G)) { goto l1229; }  yyDo(G, yy_2_ListContinuationBlock, G->begin, G->end);  goto l1228;
+  l1229:;	  G->pos= yypos1229; G->thunkpos= yythunkpos1229;
+  }  yyDo(G, yy_3_ListContinuationBlock, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ListContinuationBlock", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1225:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ListContinuationBlock", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ListBlock(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "ListBlock"));  if (!yy_StartList(G)) { goto l1230; }  yyDo(G, yySet, -1, 0);
+  {  int yypos1231= G->pos, yythunkpos1231= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1231; }  goto l1230;
+  l1231:;	  G->pos= yypos1231; G->thunkpos= yythunkpos1231;
+  }  if (!yy_Line(G)) { goto l1230; }  yyDo(G, yy_1_ListBlock, G->begin, G->end);
+  l1232:;	
+  {  int yypos1233= G->pos, yythunkpos1233= G->thunkpos;  if (!yy_ListBlockLine(G)) { goto l1233; }  yyDo(G, yy_2_ListBlock, G->begin, G->end);  goto l1232;
+  l1233:;	  G->pos= yypos1233; G->thunkpos= yythunkpos1233;
+  }  yyDo(G, yy_3_ListBlock, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ListBlock", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1230:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ListBlock", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ListItem(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "ListItem"));
+  {  int yypos1235= G->pos, yythunkpos1235= G->thunkpos;  if (!yy_Bullet(G)) { goto l1236; }  goto l1235;
+  l1236:;	  G->pos= yypos1235; G->thunkpos= yythunkpos1235;  if (!yy_Enumerator(G)) { goto l1234; }
+  }
+  l1235:;	  if (!yy_StartList(G)) { goto l1234; }  yyDo(G, yySet, -1, 0);  if (!yy_ListBlock(G)) { goto l1234; }  yyDo(G, yy_1_ListItem, G->begin, G->end);
+  l1237:;	
+  {  int yypos1238= G->pos, yythunkpos1238= G->thunkpos;  if (!yy_ListContinuationBlock(G)) { goto l1238; }  yyDo(G, yy_2_ListItem, G->begin, G->end);  goto l1237;
+  l1238:;	  G->pos= yypos1238; G->thunkpos= yythunkpos1238;
+  }  yyDo(G, yy_3_ListItem, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ListItem", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1234:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ListItem", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Enumerator(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Enumerator"));  if (!yy_NonindentSpace(G)) { goto l1239; }  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1239;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l1239;
+  l1240:;	
+  {  int yypos1241= G->pos, yythunkpos1241= G->thunkpos;  if (!yymatchClass(G, (unsigned char *)"\000\000\000\000\000\000\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l1241;  goto l1240;
+  l1241:;	  G->pos= yypos1241; G->thunkpos= yythunkpos1241;
+  }  if (!yymatchChar(G, '.')) goto l1239;  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1239;  if (!yy_Spacechar(G)) { goto l1239; }
+  l1242:;	
+  {  int yypos1243= G->pos, yythunkpos1243= G->thunkpos;  if (!yy_Spacechar(G)) { goto l1243; }  goto l1242;
+  l1243:;	  G->pos= yypos1243; G->thunkpos= yythunkpos1243;
+  }  yyDo(G, yy_1_Enumerator, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Enumerator", G->buf+G->pos));
+  return 1;
+  l1239:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Enumerator", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ListItemTight(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "ListItemTight"));
+  {  int yypos1245= G->pos, yythunkpos1245= G->thunkpos;  if (!yy_Bullet(G)) { goto l1246; }  goto l1245;
+  l1246:;	  G->pos= yypos1245; G->thunkpos= yythunkpos1245;  if (!yy_Enumerator(G)) { goto l1244; }
+  }
+  l1245:;	  if (!yy_StartList(G)) { goto l1244; }  yyDo(G, yySet, -1, 0);  if (!yy_ListBlock(G)) { goto l1244; }  yyDo(G, yy_1_ListItemTight, G->begin, G->end);
+  l1247:;	
+  {  int yypos1248= G->pos, yythunkpos1248= G->thunkpos;
+  {  int yypos1249= G->pos, yythunkpos1249= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1249; }  goto l1248;
+  l1249:;	  G->pos= yypos1249; G->thunkpos= yythunkpos1249;
+  }  if (!yy_ListContinuationBlock(G)) { goto l1248; }  yyDo(G, yy_2_ListItemTight, G->begin, G->end);  goto l1247;
+  l1248:;	  G->pos= yypos1248; G->thunkpos= yythunkpos1248;
+  }
+  {  int yypos1250= G->pos, yythunkpos1250= G->thunkpos;  if (!yy_ListContinuationBlock(G)) { goto l1250; }  goto l1244;
+  l1250:;	  G->pos= yypos1250; G->thunkpos= yythunkpos1250;
+  }  yyDo(G, yy_3_ListItemTight, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ListItemTight", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1244:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ListItemTight", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ListLoose(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 2, 0);
+  yyprintf((stderr, "%s\n", "ListLoose"));  if (!yy_StartList(G)) { goto l1251; }  yyDo(G, yySet, -2, 0);  if (!yy_ListItem(G)) { goto l1251; }  yyDo(G, yySet, -1, 0);
+  l1254:;	
+  {  int yypos1255= G->pos, yythunkpos1255= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1255; }  goto l1254;
+  l1255:;	  G->pos= yypos1255; G->thunkpos= yythunkpos1255;
+  }  yyDo(G, yy_1_ListLoose, G->begin, G->end);
+  l1252:;	
+  {  int yypos1253= G->pos, yythunkpos1253= G->thunkpos;  if (!yy_ListItem(G)) { goto l1253; }  yyDo(G, yySet, -1, 0);
+  l1256:;	
+  {  int yypos1257= G->pos, yythunkpos1257= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1257; }  goto l1256;
+  l1257:;	  G->pos= yypos1257; G->thunkpos= yythunkpos1257;
+  }  yyDo(G, yy_1_ListLoose, G->begin, G->end);  goto l1252;
+  l1253:;	  G->pos= yypos1253; G->thunkpos= yythunkpos1253;
+  }  yyDo(G, yy_2_ListLoose, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ListLoose", G->buf+G->pos));  yyDo(G, yyPop, 2, 0);
+  return 1;
+  l1251:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ListLoose", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_ListTight(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "ListTight"));  if (!yy_StartList(G)) { goto l1258; }  yyDo(G, yySet, -1, 0);  if (!yy_ListItemTight(G)) { goto l1258; }  yyDo(G, yy_1_ListTight, G->begin, G->end);
+  l1259:;	
+  {  int yypos1260= G->pos, yythunkpos1260= G->thunkpos;  if (!yy_ListItemTight(G)) { goto l1260; }  yyDo(G, yy_1_ListTight, G->begin, G->end);  goto l1259;
+  l1260:;	  G->pos= yypos1260; G->thunkpos= yythunkpos1260;
+  }
+  l1261:;	
+  {  int yypos1262= G->pos, yythunkpos1262= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1262; }  goto l1261;
+  l1262:;	  G->pos= yypos1262; G->thunkpos= yythunkpos1262;
+  }
+  {  int yypos1263= G->pos, yythunkpos1263= G->thunkpos;
+  {  int yypos1264= G->pos, yythunkpos1264= G->thunkpos;  if (!yy_Bullet(G)) { goto l1265; }  goto l1264;
+  l1265:;	  G->pos= yypos1264; G->thunkpos= yythunkpos1264;  if (!yy_Enumerator(G)) { goto l1263; }
+  }
+  l1264:;	  goto l1258;
+  l1263:;	  G->pos= yypos1263; G->thunkpos= yythunkpos1263;
+  }  yyDo(G, yy_2_ListTight, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "ListTight", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1258:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "ListTight", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Spacechar(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Spacechar"));
+  {  int yypos1267= G->pos, yythunkpos1267= G->thunkpos;  if (!yymatchChar(G, ' ')) goto l1268;  goto l1267;
+  l1268:;	  G->pos= yypos1267; G->thunkpos= yythunkpos1267;  if (!yymatchChar(G, '\t')) goto l1266;
+  }
+  l1267:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Spacechar", G->buf+G->pos));
+  return 1;
+  l1266:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Spacechar", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Bullet(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Bullet"));
+  {  int yypos1270= G->pos, yythunkpos1270= G->thunkpos;  if (!yy_HorizontalRule(G)) { goto l1270; }  goto l1269;
+  l1270:;	  G->pos= yypos1270; G->thunkpos= yythunkpos1270;
+  }  if (!yy_NonindentSpace(G)) { goto l1269; }  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1269;
+  {  int yypos1271= G->pos, yythunkpos1271= G->thunkpos;  if (!yymatchChar(G, '+')) goto l1272;  goto l1271;
+  l1272:;	  G->pos= yypos1271; G->thunkpos= yythunkpos1271;  if (!yymatchChar(G, '*')) goto l1273;  goto l1271;
+  l1273:;	  G->pos= yypos1271; G->thunkpos= yythunkpos1271;  if (!yymatchChar(G, '-')) goto l1269;
+  }
+  l1271:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1269;  if (!yy_Spacechar(G)) { goto l1269; }
+  l1274:;	
+  {  int yypos1275= G->pos, yythunkpos1275= G->thunkpos;  if (!yy_Spacechar(G)) { goto l1275; }  goto l1274;
+  l1275:;	  G->pos= yypos1275; G->thunkpos= yythunkpos1275;
+  }  yyDo(G, yy_1_Bullet, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Bullet", G->buf+G->pos));
+  return 1;
+  l1269:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Bullet", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_VerbatimChunk(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "VerbatimChunk"));
+  l1277:;	
+  {  int yypos1278= G->pos, yythunkpos1278= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1278; }  goto l1277;
+  l1278:;	  G->pos= yypos1278; G->thunkpos= yythunkpos1278;
+  }  if (!yy_NonblankIndentedLine(G)) { goto l1276; }
+  l1279:;	
+  {  int yypos1280= G->pos, yythunkpos1280= G->thunkpos;  if (!yy_NonblankIndentedLine(G)) { goto l1280; }  goto l1279;
+  l1280:;	  G->pos= yypos1280; G->thunkpos= yythunkpos1280;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "VerbatimChunk", G->buf+G->pos));
+  return 1;
+  l1276:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "VerbatimChunk", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_IndentedLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "IndentedLine"));  if (!yy_Indent(G)) { goto l1281; }  if (!yy_Line(G)) { goto l1281; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "IndentedLine", G->buf+G->pos));
+  return 1;
+  l1281:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "IndentedLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_NonblankIndentedLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "NonblankIndentedLine"));
+  {  int yypos1283= G->pos, yythunkpos1283= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1283; }  goto l1282;
+  l1283:;	  G->pos= yypos1283; G->thunkpos= yythunkpos1283;
+  }  if (!yy_IndentedLine(G)) { goto l1282; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "NonblankIndentedLine", G->buf+G->pos));
+  return 1;
+  l1282:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "NonblankIndentedLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Line(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Line"));  if (!yy_RawLine(G)) { goto l1284; }  yyDo(G, yy_1_Line, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Line", G->buf+G->pos));
+  return 1;
+  l1284:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Line", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_StartList(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "StartList"));
+  {  int yypos1286= G->pos, yythunkpos1286= G->thunkpos;  if (!yymatchDot(G)) goto l1285;  G->pos= yypos1286; G->thunkpos= yythunkpos1286;
+  }  yyDo(G, yy_1_StartList, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "StartList", G->buf+G->pos));
+  return 1;
+  l1285:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "StartList", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_BlockQuoteRaw(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "BlockQuoteRaw"));  if (!yy_StartList(G)) { goto l1287; }  yyDo(G, yySet, -1, 0);  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1287;  if (!yymatchChar(G, '>')) goto l1287;
+  {  int yypos1290= G->pos, yythunkpos1290= G->thunkpos;  if (!yymatchChar(G, ' ')) goto l1290;  goto l1291;
+  l1290:;	  G->pos= yypos1290; G->thunkpos= yythunkpos1290;
+  }
+  l1291:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1287;  yyDo(G, yy_1_BlockQuoteRaw, G->begin, G->end);  if (!yy_Line(G)) { goto l1287; }  yyDo(G, yy_2_BlockQuoteRaw, G->begin, G->end);
+  l1292:;	
+  {  int yypos1293= G->pos, yythunkpos1293= G->thunkpos;
+  {  int yypos1294= G->pos, yythunkpos1294= G->thunkpos;  if (!yymatchChar(G, '>')) goto l1294;  goto l1293;
+  l1294:;	  G->pos= yypos1294; G->thunkpos= yythunkpos1294;
+  }
+  {  int yypos1295= G->pos, yythunkpos1295= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1295; }  goto l1293;
+  l1295:;	  G->pos= yypos1295; G->thunkpos= yythunkpos1295;
+  }  if (!yy_Line(G)) { goto l1293; }  yyDo(G, yy_3_BlockQuoteRaw, G->begin, G->end);  goto l1292;
+  l1293:;	  G->pos= yypos1293; G->thunkpos= yythunkpos1293;
+  }
+  l1296:;	
+  {  int yypos1297= G->pos, yythunkpos1297= G->thunkpos;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1297;  if (!yy_BlankLine(G)) { goto l1297; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1297;  yyDo(G, yy_4_BlockQuoteRaw, G->begin, G->end);  goto l1296;
+  l1297:;	  G->pos= yypos1297; G->thunkpos= yythunkpos1297;
+  }
+  l1288:;	
+  {  int yypos1289= G->pos, yythunkpos1289= G->thunkpos;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1289;  if (!yymatchChar(G, '>')) goto l1289;
+  {  int yypos1298= G->pos, yythunkpos1298= G->thunkpos;  if (!yymatchChar(G, ' ')) goto l1298;  goto l1299;
+  l1298:;	  G->pos= yypos1298; G->thunkpos= yythunkpos1298;
+  }
+  l1299:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1289;  yyDo(G, yy_1_BlockQuoteRaw, G->begin, G->end);  if (!yy_Line(G)) { goto l1289; }  yyDo(G, yy_2_BlockQuoteRaw, G->begin, G->end);
+  l1300:;	
+  {  int yypos1301= G->pos, yythunkpos1301= G->thunkpos;
+  {  int yypos1302= G->pos, yythunkpos1302= G->thunkpos;  if (!yymatchChar(G, '>')) goto l1302;  goto l1301;
+  l1302:;	  G->pos= yypos1302; G->thunkpos= yythunkpos1302;
+  }
+  {  int yypos1303= G->pos, yythunkpos1303= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1303; }  goto l1301;
+  l1303:;	  G->pos= yypos1303; G->thunkpos= yythunkpos1303;
+  }  if (!yy_Line(G)) { goto l1301; }  yyDo(G, yy_3_BlockQuoteRaw, G->begin, G->end);  goto l1300;
+  l1301:;	  G->pos= yypos1301; G->thunkpos= yythunkpos1301;
+  }
+  l1304:;	
+  {  int yypos1305= G->pos, yythunkpos1305= G->thunkpos;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1305;  if (!yy_BlankLine(G)) { goto l1305; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1305;  yyDo(G, yy_4_BlockQuoteRaw, G->begin, G->end);  goto l1304;
+  l1305:;	  G->pos= yypos1305; G->thunkpos= yythunkpos1305;
+  }  goto l1288;
+  l1289:;	  G->pos= yypos1289; G->thunkpos= yythunkpos1289;
+  }  yyDo(G, yy_5_BlockQuoteRaw, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "BlockQuoteRaw", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1287:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "BlockQuoteRaw", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Endline(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Endline"));
+  {  int yypos1307= G->pos, yythunkpos1307= G->thunkpos;  if (!yy_LineBreak(G)) { goto l1308; }  goto l1307;
+  l1308:;	  G->pos= yypos1307; G->thunkpos= yythunkpos1307;  if (!yy_TerminalEndline(G)) { goto l1309; }  goto l1307;
+  l1309:;	  G->pos= yypos1307; G->thunkpos= yythunkpos1307;  if (!yy_NormalEndline(G)) { goto l1306; }
+  }
+  l1307:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Endline", G->buf+G->pos));
+  return 1;
+  l1306:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Endline", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_RawLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "RawLine"));
+  {  int yypos1311= G->pos, yythunkpos1311= G->thunkpos;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1312;
+  l1313:;	
+  {  int yypos1314= G->pos, yythunkpos1314= G->thunkpos;
+  {  int yypos1315= G->pos, yythunkpos1315= G->thunkpos;  if (!yymatchChar(G, '\r')) goto l1315;  goto l1314;
+  l1315:;	  G->pos= yypos1315; G->thunkpos= yythunkpos1315;
+  }
+  {  int yypos1316= G->pos, yythunkpos1316= G->thunkpos;  if (!yymatchChar(G, '\n')) goto l1316;  goto l1314;
+  l1316:;	  G->pos= yypos1316; G->thunkpos= yythunkpos1316;
+  }  if (!yymatchDot(G)) goto l1314;  goto l1313;
+  l1314:;	  G->pos= yypos1314; G->thunkpos= yythunkpos1314;
+  }  if (!yy_Newline(G)) { goto l1312; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1312;  goto l1311;
+  l1312:;	  G->pos= yypos1311; G->thunkpos= yythunkpos1311;  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1310;  if (!yymatchDot(G)) goto l1310;
+  l1317:;	
+  {  int yypos1318= G->pos, yythunkpos1318= G->thunkpos;  if (!yymatchDot(G)) goto l1318;  goto l1317;
+  l1318:;	  G->pos= yypos1318; G->thunkpos= yythunkpos1318;
+  }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1310;  if (!yy_Eof(G)) { goto l1310; }
+  }
+  l1311:;	  yyDo(G, yy_1_RawLine, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "RawLine", G->buf+G->pos));
+  return 1;
+  l1310:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "RawLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SetextBottom2(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "SetextBottom2"));  if (!yymatchChar(G, '-')) goto l1319;
+  l1320:;	
+  {  int yypos1321= G->pos, yythunkpos1321= G->thunkpos;  if (!yymatchChar(G, '-')) goto l1321;  goto l1320;
+  l1321:;	  G->pos= yypos1321; G->thunkpos= yythunkpos1321;
+  }  if (!yy_Newline(G)) { goto l1319; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "SetextBottom2", G->buf+G->pos));
+  return 1;
+  l1319:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "SetextBottom2", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SetextBottom1(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "SetextBottom1"));  if (!yymatchChar(G, '=')) goto l1322;
+  l1323:;	
+  {  int yypos1324= G->pos, yythunkpos1324= G->thunkpos;  if (!yymatchChar(G, '=')) goto l1324;  goto l1323;
+  l1324:;	  G->pos= yypos1324; G->thunkpos= yythunkpos1324;
+  }  if (!yy_Newline(G)) { goto l1322; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "SetextBottom1", G->buf+G->pos));
+  return 1;
+  l1322:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "SetextBottom1", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SetextHeading2(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "SetextHeading2"));
+  {  int yypos1326= G->pos, yythunkpos1326= G->thunkpos;  if (!yy_RawLine(G)) { goto l1325; }  if (!yy_SetextBottom2(G)) { goto l1325; }  G->pos= yypos1326; G->thunkpos= yythunkpos1326;
+  }  if (!yy_LocMarker(G)) { goto l1325; }  yyDo(G, yySet, -1, 0);  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1325;
+  {  int yypos1329= G->pos, yythunkpos1329= G->thunkpos;  if (!yy_Endline(G)) { goto l1329; }  goto l1325;
+  l1329:;	  G->pos= yypos1329; G->thunkpos= yythunkpos1329;
+  }  if (!yy_Inline(G)) { goto l1325; }
+  l1327:;	
+  {  int yypos1328= G->pos, yythunkpos1328= G->thunkpos;
+  {  int yypos1330= G->pos, yythunkpos1330= G->thunkpos;  if (!yy_Endline(G)) { goto l1330; }  goto l1328;
+  l1330:;	  G->pos= yypos1330; G->thunkpos= yythunkpos1330;
+  }  if (!yy_Inline(G)) { goto l1328; }  goto l1327;
+  l1328:;	  G->pos= yypos1328; G->thunkpos= yythunkpos1328;
+  }  if (!yy_Sp(G)) { goto l1325; }  if (!yy_Newline(G)) { goto l1325; }  if (!yy_SetextBottom2(G)) { goto l1325; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1325;  yyDo(G, yy_1_SetextHeading2, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "SetextHeading2", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1325:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "SetextHeading2", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SetextHeading1(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "SetextHeading1"));
+  {  int yypos1332= G->pos, yythunkpos1332= G->thunkpos;  if (!yy_RawLine(G)) { goto l1331; }  if (!yy_SetextBottom1(G)) { goto l1331; }  G->pos= yypos1332; G->thunkpos= yythunkpos1332;
+  }  if (!yy_LocMarker(G)) { goto l1331; }  yyDo(G, yySet, -1, 0);  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1331;
+  {  int yypos1335= G->pos, yythunkpos1335= G->thunkpos;  if (!yy_Endline(G)) { goto l1335; }  goto l1331;
+  l1335:;	  G->pos= yypos1335; G->thunkpos= yythunkpos1335;
+  }  if (!yy_Inline(G)) { goto l1331; }
+  l1333:;	
+  {  int yypos1334= G->pos, yythunkpos1334= G->thunkpos;
+  {  int yypos1336= G->pos, yythunkpos1336= G->thunkpos;  if (!yy_Endline(G)) { goto l1336; }  goto l1334;
+  l1336:;	  G->pos= yypos1336; G->thunkpos= yythunkpos1336;
+  }  if (!yy_Inline(G)) { goto l1334; }  goto l1333;
+  l1334:;	  G->pos= yypos1334; G->thunkpos= yythunkpos1334;
+  }  if (!yy_Sp(G)) { goto l1331; }  if (!yy_Newline(G)) { goto l1331; }  if (!yy_SetextBottom1(G)) { goto l1331; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1331;  yyDo(G, yy_1_SetextHeading1, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "SetextHeading1", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1331:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "SetextHeading1", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_SetextHeading(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "SetextHeading"));
+  {  int yypos1338= G->pos, yythunkpos1338= G->thunkpos;  if (!yy_SetextHeading1(G)) { goto l1339; }  goto l1338;
+  l1339:;	  G->pos= yypos1338; G->thunkpos= yythunkpos1338;  if (!yy_SetextHeading2(G)) { goto l1337; }
+  }
+  l1338:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "SetextHeading", G->buf+G->pos));
+  return 1;
+  l1337:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "SetextHeading", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_AtxHeading(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "AtxHeading"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1340;  if (!yy_AtxStart(G)) { goto l1340; }  yyDo(G, yySet, -1, 0);  if (!yy_Sp(G)) { goto l1340; }  if (!yy_AtxInline(G)) { goto l1340; }
+  l1341:;	
+  {  int yypos1342= G->pos, yythunkpos1342= G->thunkpos;  if (!yy_AtxInline(G)) { goto l1342; }  goto l1341;
+  l1342:;	  G->pos= yypos1342; G->thunkpos= yythunkpos1342;
+  }
+  {  int yypos1343= G->pos, yythunkpos1343= G->thunkpos;  if (!yy_Sp(G)) { goto l1343; }
+  l1345:;	
+  {  int yypos1346= G->pos, yythunkpos1346= G->thunkpos;  if (!yymatchChar(G, '#')) goto l1346;  goto l1345;
+  l1346:;	  G->pos= yypos1346; G->thunkpos= yythunkpos1346;
+  }  if (!yy_Sp(G)) { goto l1343; }  goto l1344;
+  l1343:;	  G->pos= yypos1343; G->thunkpos= yythunkpos1343;
+  }
+  l1344:;	  if (!yy_Newline(G)) { goto l1340; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1340;  yyDo(G, yy_1_AtxHeading, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "AtxHeading", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1340:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "AtxHeading", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_AtxStart(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "AtxStart"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1347;
+  {  int yypos1348= G->pos, yythunkpos1348= G->thunkpos;  if (!yymatchString(G, "######")) goto l1349;  goto l1348;
+  l1349:;	  G->pos= yypos1348; G->thunkpos= yythunkpos1348;  if (!yymatchString(G, "#####")) goto l1350;  goto l1348;
+  l1350:;	  G->pos= yypos1348; G->thunkpos= yythunkpos1348;  if (!yymatchString(G, "####")) goto l1351;  goto l1348;
+  l1351:;	  G->pos= yypos1348; G->thunkpos= yythunkpos1348;  if (!yymatchString(G, "###")) goto l1352;  goto l1348;
+  l1352:;	  G->pos= yypos1348; G->thunkpos= yythunkpos1348;  if (!yymatchString(G, "##")) goto l1353;  goto l1348;
+  l1353:;	  G->pos= yypos1348; G->thunkpos= yythunkpos1348;  if (!yymatchChar(G, '#')) goto l1347;
+  }
+  l1348:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1347;  yyDo(G, yy_1_AtxStart, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "AtxStart", G->buf+G->pos));
+  return 1;
+  l1347:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "AtxStart", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Inline(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Inline"));
+  {  int yypos1355= G->pos, yythunkpos1355= G->thunkpos;  if (!yy_Str(G)) { goto l1356; }  goto l1355;
+  l1356:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Endline(G)) { goto l1357; }  goto l1355;
+  l1357:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_UlOrStarLine(G)) { goto l1358; }  goto l1355;
+  l1358:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Space(G)) { goto l1359; }  goto l1355;
+  l1359:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Strong(G)) { goto l1360; }  goto l1355;
+  l1360:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Emph(G)) { goto l1361; }  goto l1355;
+  l1361:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Strike(G)) { goto l1362; }  goto l1355;
+  l1362:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Image(G)) { goto l1363; }  goto l1355;
+  l1363:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Link(G)) { goto l1364; }  goto l1355;
+  l1364:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_NoteReference(G)) { goto l1365; }  goto l1355;
+  l1365:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_InlineNote(G)) { goto l1366; }  goto l1355;
+  l1366:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Code(G)) { goto l1367; }  goto l1355;
+  l1367:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_RawHtml(G)) { goto l1368; }  goto l1355;
+  l1368:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Entity(G)) { goto l1369; }  goto l1355;
+  l1369:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_EscapedChar(G)) { goto l1370; }  goto l1355;
+  l1370:;	  G->pos= yypos1355; G->thunkpos= yythunkpos1355;  if (!yy_Symbol(G)) { goto l1354; }
+  }
+  l1355:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Inline", G->buf+G->pos));
+  return 1;
+  l1354:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Inline", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Sp(GREG *G)
+{
+  yyprintf((stderr, "%s\n", "Sp"));
+  l1372:;	
+  {  int yypos1373= G->pos, yythunkpos1373= G->thunkpos;  if (!yy_Spacechar(G)) { goto l1373; }  goto l1372;
+  l1373:;	  G->pos= yypos1373; G->thunkpos= yythunkpos1373;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Sp", G->buf+G->pos));
+  return 1;
+}
+YY_RULE(int) yy_Newline(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Newline"));
+  {  int yypos1375= G->pos, yythunkpos1375= G->thunkpos;  if (!yymatchChar(G, '\n')) goto l1376;  goto l1375;
+  l1376:;	  G->pos= yypos1375; G->thunkpos= yythunkpos1375;  if (!yymatchChar(G, '\r')) goto l1374;
+  {  int yypos1377= G->pos, yythunkpos1377= G->thunkpos;  if (!yymatchChar(G, '\n')) goto l1377;  goto l1378;
+  l1377:;	  G->pos= yypos1377; G->thunkpos= yythunkpos1377;
+  }
+  l1378:;	
+  }
+  l1375:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Newline", G->buf+G->pos));
+  return 1;
+  l1374:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Newline", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_AtxInline(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "AtxInline"));
+  {  int yypos1380= G->pos, yythunkpos1380= G->thunkpos;  if (!yy_Newline(G)) { goto l1380; }  goto l1379;
+  l1380:;	  G->pos= yypos1380; G->thunkpos= yythunkpos1380;
+  }
+  {  int yypos1381= G->pos, yythunkpos1381= G->thunkpos;  if (!yy_Sp(G)) { goto l1381; }
+  l1382:;	
+  {  int yypos1383= G->pos, yythunkpos1383= G->thunkpos;  if (!yymatchChar(G, '#')) goto l1383;  goto l1382;
+  l1383:;	  G->pos= yypos1383; G->thunkpos= yythunkpos1383;
+  }  if (!yy_Sp(G)) { goto l1381; }  if (!yy_Newline(G)) { goto l1381; }  goto l1379;
+  l1381:;	  G->pos= yypos1381; G->thunkpos= yythunkpos1381;
+  }  if (!yy_Inline(G)) { goto l1379; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "AtxInline", G->buf+G->pos));
+  return 1;
+  l1379:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "AtxInline", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Inlines(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Inlines"));
+  {  int yypos1387= G->pos, yythunkpos1387= G->thunkpos;
+  {  int yypos1389= G->pos, yythunkpos1389= G->thunkpos;  if (!yy_Endline(G)) { goto l1389; }  goto l1388;
+  l1389:;	  G->pos= yypos1389; G->thunkpos= yythunkpos1389;
+  }  if (!yy_Inline(G)) { goto l1388; }  goto l1387;
+  l1388:;	  G->pos= yypos1387; G->thunkpos= yythunkpos1387;  if (!yy_Endline(G)) { goto l1384; }
+  {  int yypos1390= G->pos, yythunkpos1390= G->thunkpos;  if (!yy_Inline(G)) { goto l1384; }  G->pos= yypos1390; G->thunkpos= yythunkpos1390;
+  }
+  }
+  l1387:;	
+  l1385:;	
+  {  int yypos1386= G->pos, yythunkpos1386= G->thunkpos;
+  {  int yypos1391= G->pos, yythunkpos1391= G->thunkpos;
+  {  int yypos1393= G->pos, yythunkpos1393= G->thunkpos;  if (!yy_Endline(G)) { goto l1393; }  goto l1392;
+  l1393:;	  G->pos= yypos1393; G->thunkpos= yythunkpos1393;
+  }  if (!yy_Inline(G)) { goto l1392; }  goto l1391;
+  l1392:;	  G->pos= yypos1391; G->thunkpos= yythunkpos1391;  if (!yy_Endline(G)) { goto l1386; }
+  {  int yypos1394= G->pos, yythunkpos1394= G->thunkpos;  if (!yy_Inline(G)) { goto l1386; }  G->pos= yypos1394; G->thunkpos= yythunkpos1394;
+  }
+  }
+  l1391:;	  goto l1385;
+  l1386:;	  G->pos= yypos1386; G->thunkpos= yythunkpos1386;
+  }
+  {  int yypos1395= G->pos, yythunkpos1395= G->thunkpos;  if (!yy_Endline(G)) { goto l1395; }  goto l1396;
+  l1395:;	  G->pos= yypos1395; G->thunkpos= yythunkpos1395;
+  }
+  l1396:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Inlines", G->buf+G->pos));
+  return 1;
+  l1384:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Inlines", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_NonindentSpace(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "NonindentSpace"));
+  {  int yypos1398= G->pos, yythunkpos1398= G->thunkpos;  if (!yymatchString(G, "   ")) goto l1399;  goto l1398;
+  l1399:;	  G->pos= yypos1398; G->thunkpos= yythunkpos1398;  if (!yymatchString(G, "  ")) goto l1400;  goto l1398;
+  l1400:;	  G->pos= yypos1398; G->thunkpos= yythunkpos1398;  if (!yymatchChar(G, ' ')) goto l1401;  goto l1398;
+  l1401:;	  G->pos= yypos1398; G->thunkpos= yythunkpos1398;  if (!yymatchString(G, "")) goto l1397;
+  }
+  l1398:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "NonindentSpace", G->buf+G->pos));
+  return 1;
+  l1397:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "NonindentSpace", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Plain(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Plain"));  if (!yy_Inlines(G)) { goto l1402; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Plain", G->buf+G->pos));
+  return 1;
+  l1402:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Plain", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Para(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Para"));  if (!yy_NonindentSpace(G)) { goto l1403; }  if (!yy_Inlines(G)) { goto l1403; }  if (!yy_BlankLine(G)) { goto l1403; }
+  l1404:;	
+  {  int yypos1405= G->pos, yythunkpos1405= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1405; }  goto l1404;
+  l1405:;	  G->pos= yypos1405; G->thunkpos= yythunkpos1405;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Para", G->buf+G->pos));
+  return 1;
+  l1403:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Para", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_StyleBlock(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "StyleBlock"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1406;  if (!yy_LocMarker(G)) { goto l1406; }  yyDo(G, yySet, -1, 0);  if (!yy_InStyleTags(G)) { goto l1406; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1406;
+  l1407:;	
+  {  int yypos1408= G->pos, yythunkpos1408= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1408; }  goto l1407;
+  l1408:;	  G->pos= yypos1408; G->thunkpos= yythunkpos1408;
+  }  yyDo(G, yy_1_StyleBlock, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "StyleBlock", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1406:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "StyleBlock", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HtmlBlock(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "HtmlBlock"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1409;  if (!yy_LocMarker(G)) { goto l1409; }  yyDo(G, yySet, -1, 0);
+  {  int yypos1410= G->pos, yythunkpos1410= G->thunkpos;  if (!yy_HtmlBlockInTags(G)) { goto l1411; }  goto l1410;
+  l1411:;	  G->pos= yypos1410; G->thunkpos= yythunkpos1410;  if (!yy_HtmlComment(G)) { goto l1412; }  goto l1410;
+  l1412:;	  G->pos= yypos1410; G->thunkpos= yythunkpos1410;  if (!yy_HtmlBlockSelfClosing(G)) { goto l1409; }
+  }
+  l1410:;	  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1409;  if (!yy_BlankLine(G)) { goto l1409; }
+  l1413:;	
+  {  int yypos1414= G->pos, yythunkpos1414= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1414; }  goto l1413;
+  l1414:;	  G->pos= yypos1414; G->thunkpos= yythunkpos1414;
+  }  yyDo(G, yy_1_HtmlBlock, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HtmlBlock", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1409:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HtmlBlock", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_BulletList(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "BulletList"));
+  {  int yypos1416= G->pos, yythunkpos1416= G->thunkpos;  if (!yy_Bullet(G)) { goto l1415; }  G->pos= yypos1416; G->thunkpos= yythunkpos1416;
+  }
+  {  int yypos1417= G->pos, yythunkpos1417= G->thunkpos;  if (!yy_ListTight(G)) { goto l1418; }  goto l1417;
+  l1418:;	  G->pos= yypos1417; G->thunkpos= yythunkpos1417;  if (!yy_ListLoose(G)) { goto l1415; }
+  }
+  l1417:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "BulletList", G->buf+G->pos));
+  return 1;
+  l1415:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "BulletList", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_OrderedList(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "OrderedList"));
+  {  int yypos1420= G->pos, yythunkpos1420= G->thunkpos;  if (!yy_Enumerator(G)) { goto l1419; }  G->pos= yypos1420; G->thunkpos= yythunkpos1420;
+  }
+  {  int yypos1421= G->pos, yythunkpos1421= G->thunkpos;  if (!yy_ListTight(G)) { goto l1422; }  goto l1421;
+  l1422:;	  G->pos= yypos1421; G->thunkpos= yythunkpos1421;  if (!yy_ListLoose(G)) { goto l1419; }
+  }
+  l1421:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "OrderedList", G->buf+G->pos));
+  return 1;
+  l1419:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "OrderedList", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Heading(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Heading"));
+  {  int yypos1424= G->pos, yythunkpos1424= G->thunkpos;  if (!yy_SetextHeading(G)) { goto l1425; }  goto l1424;
+  l1425:;	  G->pos= yypos1424; G->thunkpos= yythunkpos1424;  if (!yy_AtxHeading(G)) { goto l1423; }
+  }
+  l1424:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Heading", G->buf+G->pos));
+  return 1;
+  l1423:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Heading", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_HorizontalRule(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "HorizontalRule"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1426;  if (!yy_NonindentSpace(G)) { goto l1426; }
+  {  int yypos1427= G->pos, yythunkpos1427= G->thunkpos;  if (!yymatchChar(G, '*')) goto l1428;  if (!yy_Sp(G)) { goto l1428; }  if (!yymatchChar(G, '*')) goto l1428;  if (!yy_Sp(G)) { goto l1428; }  if (!yymatchChar(G, '*')) goto l1428;
+  l1429:;	
+  {  int yypos1430= G->pos, yythunkpos1430= G->thunkpos;  if (!yy_Sp(G)) { goto l1430; }  if (!yymatchChar(G, '*')) goto l1430;  goto l1429;
+  l1430:;	  G->pos= yypos1430; G->thunkpos= yythunkpos1430;
+  }  goto l1427;
+  l1428:;	  G->pos= yypos1427; G->thunkpos= yythunkpos1427;  if (!yymatchChar(G, '-')) goto l1431;  if (!yy_Sp(G)) { goto l1431; }  if (!yymatchChar(G, '-')) goto l1431;  if (!yy_Sp(G)) { goto l1431; }  if (!yymatchChar(G, '-')) goto l1431;
+  l1432:;	
+  {  int yypos1433= G->pos, yythunkpos1433= G->thunkpos;  if (!yy_Sp(G)) { goto l1433; }  if (!yymatchChar(G, '-')) goto l1433;  goto l1432;
+  l1433:;	  G->pos= yypos1433; G->thunkpos= yythunkpos1433;
+  }  goto l1427;
+  l1431:;	  G->pos= yypos1427; G->thunkpos= yythunkpos1427;  if (!yymatchChar(G, '_')) goto l1426;  if (!yy_Sp(G)) { goto l1426; }  if (!yymatchChar(G, '_')) goto l1426;  if (!yy_Sp(G)) { goto l1426; }  if (!yymatchChar(G, '_')) goto l1426;
+  l1434:;	
+  {  int yypos1435= G->pos, yythunkpos1435= G->thunkpos;  if (!yy_Sp(G)) { goto l1435; }  if (!yymatchChar(G, '_')) goto l1435;  goto l1434;
+  l1435:;	  G->pos= yypos1435; G->thunkpos= yythunkpos1435;
+  }
+  }
+  l1427:;	  if (!yy_Sp(G)) { goto l1426; }  if (!yy_Newline(G)) { goto l1426; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1426;  if (!yy_BlankLine(G)) { goto l1426; }
+  l1436:;	
+  {  int yypos1437= G->pos, yythunkpos1437= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1437; }  goto l1436;
+  l1437:;	  G->pos= yypos1437; G->thunkpos= yythunkpos1437;
+  }  yyDo(G, yy_1_HorizontalRule, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "HorizontalRule", G->buf+G->pos));
+  return 1;
+  l1426:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "HorizontalRule", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Reference(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 3, 0);
+  yyprintf((stderr, "%s\n", "Reference"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1438;  if (!yy_LocMarker(G)) { goto l1438; }  yyDo(G, yySet, -3, 0);  if (!yy_NonindentSpace(G)) { goto l1438; }
+  {  int yypos1439= G->pos, yythunkpos1439= G->thunkpos;  if (!yymatchString(G, "[]")) goto l1439;  goto l1438;
+  l1439:;	  G->pos= yypos1439; G->thunkpos= yythunkpos1439;
+  }  if (!yy_Label(G)) { goto l1438; }  yyDo(G, yySet, -2, 0);  if (!yymatchChar(G, ':')) goto l1438;  if (!yy_Spnl(G)) { goto l1438; }  if (!yy_RefSrc(G)) { goto l1438; }  yyDo(G, yySet, -1, 0);  if (!yy_RefTitle(G)) { goto l1438; }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1438;  if (!yy_BlankLine(G)) { goto l1438; }
+  l1440:;	
+  {  int yypos1441= G->pos, yythunkpos1441= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1441; }  goto l1440;
+  l1441:;	  G->pos= yypos1441; G->thunkpos= yythunkpos1441;
+  }  yyDo(G, yy_1_Reference, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Reference", G->buf+G->pos));  yyDo(G, yyPop, 3, 0);
+  return 1;
+  l1438:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Reference", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Note(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Note"));  yyText(G, G->begin, G->end);  if (!( EXT(pmh_EXT_NOTES) )) goto l1442;  if (!yy_NonindentSpace(G)) { goto l1442; }  if (!yy_RawNoteReference(G)) { goto l1442; }  if (!yymatchChar(G, ':')) goto l1442;  if (!yy_Sp(G)) { goto l1442; }  if (!yy_RawNoteBlock(G)) { goto l1442; }
+  l1443:;	
+  {  int yypos1444= G->pos, yythunkpos1444= G->thunkpos;
+  {  int yypos1445= G->pos, yythunkpos1445= G->thunkpos;  if (!yy_Indent(G)) { goto l1444; }  G->pos= yypos1445; G->thunkpos= yythunkpos1445;
+  }  if (!yy_RawNoteBlock(G)) { goto l1444; }  goto l1443;
+  l1444:;	  G->pos= yypos1444; G->thunkpos= yythunkpos1444;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Note", G->buf+G->pos));
+  return 1;
+  l1442:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Note", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Verbatim(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "Verbatim"));  yyText(G, G->begin, G->end);  if (!(YY_BEGIN)) goto l1446;  if (!yy_LocMarker(G)) { goto l1446; }  yyDo(G, yySet, -1, 0);  if (!yy_VerbatimChunk(G)) { goto l1446; }
+  l1447:;	
+  {  int yypos1448= G->pos, yythunkpos1448= G->thunkpos;  if (!yy_VerbatimChunk(G)) { goto l1448; }  goto l1447;
+  l1448:;	  G->pos= yypos1448; G->thunkpos= yythunkpos1448;
+  }  yyText(G, G->begin, G->end);  if (!(YY_END)) goto l1446;  yyDo(G, yy_1_Verbatim, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "Verbatim", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1446:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Verbatim", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_BlockQuote(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;  yyDo(G, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "BlockQuote"));  if (!yy_BlockQuoteRaw(G)) { goto l1449; }  yyDo(G, yySet, -1, 0);  yyDo(G, yy_1_BlockQuote, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "BlockQuote", G->buf+G->pos));  yyDo(G, yyPop, 1, 0);
+  return 1;
+  l1449:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "BlockQuote", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_BlankLine(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "BlankLine"));  if (!yy_Sp(G)) { goto l1450; }  if (!yy_Newline(G)) { goto l1450; }
+  yyprintf((stderr, "  ok   %s @ %s\n", "BlankLine", G->buf+G->pos));
+  return 1;
+  l1450:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "BlankLine", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_LocMarker(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "LocMarker"));
+  {  int yypos1452= G->pos, yythunkpos1452= G->thunkpos;  if (!yymatchDot(G)) goto l1451;  G->pos= yypos1452; G->thunkpos= yythunkpos1452;
+  }  yyDo(G, yy_1_LocMarker, G->begin, G->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "LocMarker", G->buf+G->pos));
+  return 1;
+  l1451:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "LocMarker", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Block(GREG *G)
+{  int yypos0= G->pos, yythunkpos0= G->thunkpos;
+  yyprintf((stderr, "%s\n", "Block"));
+  l1454:;	
+  {  int yypos1455= G->pos, yythunkpos1455= G->thunkpos;  if (!yy_BlankLine(G)) { goto l1455; }  goto l1454;
+  l1455:;	  G->pos= yypos1455; G->thunkpos= yythunkpos1455;
+  }
+  {  int yypos1456= G->pos, yythunkpos1456= G->thunkpos;  if (!yy_BlockQuote(G)) { goto l1457; }  goto l1456;
+  l1457:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_Verbatim(G)) { goto l1458; }  goto l1456;
+  l1458:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_Note(G)) { goto l1459; }  goto l1456;
+  l1459:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_Reference(G)) { goto l1460; }  goto l1456;
+  l1460:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_HorizontalRule(G)) { goto l1461; }  goto l1456;
+  l1461:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_Heading(G)) { goto l1462; }  goto l1456;
+  l1462:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_OrderedList(G)) { goto l1463; }  goto l1456;
+  l1463:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_BulletList(G)) { goto l1464; }  goto l1456;
+  l1464:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_HtmlBlock(G)) { goto l1465; }  goto l1456;
+  l1465:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_StyleBlock(G)) { goto l1466; }  goto l1456;
+  l1466:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_Para(G)) { goto l1467; }  goto l1456;
+  l1467:;	  G->pos= yypos1456; G->thunkpos= yythunkpos1456;  if (!yy_Plain(G)) { goto l1453; }
+  }
+  l1456:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "Block", G->buf+G->pos));
+  return 1;
+  l1453:;	  G->pos= yypos0; G->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "Block", G->buf+G->pos));
+  return 0;
+}
+YY_RULE(int) yy_Doc(GREG *G)
+{
+  yyprintf((stderr, "%s\n", "Doc"));
+  l1469:;	
+  {  int yypos1470= G->pos, yythunkpos1470= G->thunkpos;  if (!yy_Block(G)) { goto l1470; }  goto l1469;
+  l1470:;	  G->pos= yypos1470; G->thunkpos= yythunkpos1470;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "Doc", G->buf+G->pos));
+  return 1;
+}
+
+#ifndef YY_PART
+
+typedef int (*yyrule)(GREG *G);
+
+YY_PARSE(int) YY_NAME(parse_from)(GREG *G, yyrule yystart)
+{
+  int yyok;
+  if (!G->buflen)
+    {
+      G->buflen= YY_BUFFER_START_SIZE;
+      G->buf= (char *)YY_ALLOC(G->buflen, G->data);
+      G->textlen= YY_BUFFER_START_SIZE;
+      G->text= (char *)YY_ALLOC(G->textlen, G->data);
+      G->thunkslen= YY_STACK_SIZE;
+      G->thunks= (yythunk *)YY_ALLOC(sizeof(yythunk) * G->thunkslen, G->data);
+      G->valslen= YY_STACK_SIZE;
+      G->vals= (YYSTYPE*)YY_ALLOC(sizeof(YYSTYPE) * G->valslen, G->data);
+      G->begin= G->end= G->pos= G->limit= G->thunkpos= 0;
+    }
+  G->pos = 0;
+  G->begin= G->end= G->pos;
+  G->thunkpos= 0;
+  G->val= G->vals;
+  yyok= yystart(G);
+  if (yyok) yyDone(G);
+  yyCommit(G);
+  return yyok;
+  (void)yyrefill(NULL);
+  (void)yymatchDot(NULL);
+  (void)yymatchChar(NULL, 0);
+  (void)yymatchString(NULL, NULL);
+  (void)yymatchClass(NULL, NULL);
+  (void)yyDo(NULL, NULL, 0, 0);
+  (void)yyText(NULL, 0, 0);
+  (void)yyDone(NULL);
+  (void)yyCommit(NULL);
+  (void)yyAccept(NULL, 0);
+  (void)yyPush(NULL, NULL, 0, NULL, NULL);
+  (void)yyPop(NULL, NULL, 0, NULL, NULL);
+  (void)yySet(NULL, NULL, 0, NULL, NULL);
+}
+
+YY_PARSE(int) YY_NAME(parse)(GREG *G)
+{
+  return YY_NAME(parse_from)(G, yy_Doc);
+}
+
+YY_PARSE(GREG *) YY_NAME(parse_new)(YY_XTYPE data)
+{
+  GREG *G = (GREG *)YY_CALLOC(1, sizeof(GREG), G->data);
+  G->data = data;
+  return G;
+}
+
+YY_PARSE(void) YY_NAME(parse_free)(GREG *G)
+{
+  YY_FREE(G->buf);
+  YY_FREE(G->text);
+  YY_FREE(G->thunks);
+  YY_FREE(G->vals);
+  YY_FREE(G);
+}
+
+#endif
+
+
+
+
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * pmh_parser_foot.c
+ * 
+ * Code to be appended to the end of the parser code generated from the
+ * PEG grammar.
+ */
+
+
+static void _parse(parser_data *p_data, yyrule start_rule)
+{
+    GREG *g = YY_NAME(parse_new)(p_data);
+    if (start_rule == NULL)
+        YY_NAME(parse)(g);
+    else
+        YY_NAME(parse_from)(g, start_rule);
+    YY_NAME(parse_free)(g);
+    
+    pmh_PRINTF("\n\n");
+}
+
+static void parse_markdown(parser_data *p_data)
+{
+    pmh_PRINTF("\nPARSING DOCUMENT: ");
+    
+    _parse(p_data, NULL);
+}
+
+static void parse_references(parser_data *p_data)
+{
+    pmh_PRINTF("\nPARSING REFERENCES: ");
+    
+    p_data->parsing_only_references = true;
+    _parse(p_data, yy_References);
+    p_data->parsing_only_references = false;
+    
+    p_data->references = p_data->head_elems[pmh_REFERENCE];
+    p_data->head_elems[pmh_REFERENCE] = NULL;
+}
+

+ 89 - 0
utils/peg-highlight/pmh_parser.h

@@ -0,0 +1,89 @@
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * pmh_parser.h
+ */
+
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+
+/** \file
+* \brief Parser public interface.
+*/
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#include <stdlib.h>
+#include <assert.h>
+#include "pmh_definitions.h"
+
+
+/**
+* \brief Parse Markdown text, return elements
+* 
+* Parses the given Markdown text and returns the results as an
+* array of linked lists of elements, indexed by type.
+* 
+* \param[in]  text        The Markdown text to parse for highlighting.
+* \param[in]  extensions  The extensions to use in parsing (a bitfield
+*                         of pmh_extensions values).
+* \param[out] out_result  A pmh_element array, indexed by type, containing
+*                         the results of the parsing (linked lists of elements).
+*                         You must pass this to pmh_free_elements() when it's
+*                         not needed anymore.
+* 
+* \sa pmh_element_type
+*/
+void pmh_markdown_to_elements(char *text, int extensions,
+                              pmh_element **out_result[]);
+
+/**
+* \brief Sort elements in list by start offset.
+* 
+* Sorts the linked lists of elements in the list returned by
+* pmh_markdown_to_elements() by their start offsets (pos).
+* 
+* \param[in] element_lists  Array of linked lists of elements (output
+*                           from pmh_markdown_to_elements()).
+* 
+* \sa pmh_markdown_to_elements
+* \sa pmh_element::pos
+*/
+void pmh_sort_elements_by_pos(pmh_element *element_lists[]);
+
+/**
+* \brief Free pmh_element array
+* 
+* Frees an pmh_element array returned by pmh_markdown_to_elements().
+* 
+* \param[in]  elems  The pmh_element array resulting from calling
+*                    pmh_markdown_to_elements().
+* 
+* \sa pmh_markdown_to_elements
+*/
+void pmh_free_elements(pmh_element **elems);
+
+/**
+* \brief Get element type name
+* 
+* \param[in]  type  The type value to get the name for.
+* 
+* \return The name of the given type as a null-terminated string.
+* 
+* \sa pmh_element_type
+*/
+char *pmh_element_name_from_type(pmh_element_type type);
+
+/**
+* \brief Get element type from a name
+* 
+* \param[in]  name  The name of the type.
+* 
+* \return The element type corresponding to the given name.
+* 
+* \sa pmh_element_type
+*/
+pmh_element_type pmh_element_type_from_name(char *name);
+

+ 932 - 0
utils/peg-highlight/pmh_styleparser.c

@@ -0,0 +1,932 @@
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * styleparser.c
+ * 
+ * Parser for custom syntax highlighting stylesheets.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+#include "pmh_styleparser.h"
+#include "pmh_parser.h"
+
+
+#if pmh_DEBUG_OUTPUT
+#define pmhsp_PRINTF(x, ...) fprintf(stderr, x, ##__VA_ARGS__)
+#else
+#define pmhsp_PRINTF(x, ...)
+#endif
+
+
+// vasprintf is not in the C standard nor in POSIX so we provide our own
+static int our_vasprintf(char **strptr, const char *fmt, va_list argptr)
+{
+    int ret;
+    va_list argptr2;
+    *strptr = NULL;
+    
+    va_copy(argptr2, argptr);
+    ret = vsnprintf(NULL, 0, fmt, argptr2);
+    if (ret <= 0)
+        return ret;
+    
+    *strptr = (char *)malloc(ret+1);
+    if (*strptr == NULL)
+        return -1;
+    
+    va_copy(argptr2, argptr);
+    ret = vsnprintf(*strptr, ret+1, fmt, argptr2);
+    
+    return ret;
+}
+
+
+
+// Parsing context data
+typedef struct
+{
+    char *input;
+    void (*error_callback)(char*,int,void*);
+    void *error_callback_context;
+    int styles_pos;
+    pmh_style_collection *styles;
+} style_parser_data;
+
+typedef struct raw_attribute
+{
+    char *name;
+    char *value;
+    int line_number;
+    struct raw_attribute *next;
+} raw_attribute;
+
+static raw_attribute *new_raw_attribute(char *name, char *value,
+                                        int line_number)
+{
+    raw_attribute *v = (raw_attribute *)malloc(sizeof(raw_attribute));
+    v->name = name;
+    v->value = value;
+    v->line_number = line_number;
+    v->next = NULL;
+    return v;
+}
+
+static void free_raw_attributes(raw_attribute *list)
+{
+    raw_attribute *cur = list;
+    while (cur != NULL)
+    {
+        if (cur->name != NULL) free(cur->name);
+        if (cur->value != NULL) free(cur->value);
+        raw_attribute *this = cur;
+        cur = cur->next;
+        free(this);
+    }
+}
+
+
+static void report_error(style_parser_data *p_data,
+                         int line_number, char *str, ...)
+{
+    if (p_data->error_callback == NULL)
+        return;
+    va_list argptr;
+    va_start(argptr, str);
+    char *errmsg;
+    our_vasprintf(&errmsg, str, argptr);
+    va_end(argptr);
+    p_data->error_callback(errmsg, line_number,
+                           p_data->error_callback_context);
+    free(errmsg);
+}
+
+
+
+static char *trim_str(char *str)
+{
+    while (isspace(*str))
+        str++;
+    if (*str == '\0')
+        return str;
+    char *end = str + strlen(str) - 1;
+    while (end > str && isspace(*end))
+        end--;
+    *(end+1) = '\0';
+    return str;
+}
+
+static char *trim_str_dup(char *str)
+{
+    size_t start = 0;
+    while (isspace(*(str + start)))
+        start++;
+    size_t end = strlen(str) - 1;
+    while (start < end && isspace(*(str + end)))
+        end--;
+    
+    size_t len = end - start + 1;
+    char *ret = (char *)malloc(sizeof(char)*len + 1);
+    *ret = '\0';
+    strncat(ret, (str + start), len);
+    
+    return ret;
+}
+
+static char *strcpy_lower(char *str)
+{
+    char *low = strdup(str);
+    int i;
+    int len = strlen(str);
+    for (i = 0; i < len; i++)
+        *(low+i) = tolower(*(low+i));
+    return low;
+}
+
+static char *standardize_str(char *str)
+{
+    return strcpy_lower(trim_str(str));
+}
+
+
+
+
+static pmh_attr_argb_color *new_argb_color(int r, int g, int b, int a)
+{
+    pmh_attr_argb_color *c = (pmh_attr_argb_color *)
+                             malloc(sizeof(pmh_attr_argb_color));
+    c->red = r; c->green = g; c->blue = b; c->alpha = a;
+    return c;
+}
+static pmh_attr_argb_color *new_argb_from_hex(long long hex, bool has_alpha)
+{
+    // 0xaarrggbb
+    int a = has_alpha ? ((hex >> 24) & 0xFF) : 255;
+    int r = ((hex >> 16) & 0xFF);
+    int g = ((hex >> 8) & 0xFF);
+    int b = (hex & 0xFF);
+    return new_argb_color(r,g,b,a);
+}
+static pmh_attr_argb_color *new_argb_from_hex_str(style_parser_data *p_data,
+                                                  int attr_line_number,
+                                                  char *str)
+{
+    // "aarrggbb"
+    int len = strlen(str);
+    if (len != 6 && len != 8) {
+        report_error(p_data, attr_line_number,
+                     "Value '%s' is not a valid color value: it should be a "
+                     "hexadecimal number, 6 or 8 characters long.",
+                     str);
+        return NULL;
+    }
+    char *endptr = NULL;
+    long long num = strtoll(str, &endptr, 16);
+    if (*endptr != '\0') {
+        report_error(p_data, attr_line_number,
+                     "Value '%s' is not a valid color value: the character "
+                     "'%c' is invalid. The color value should be a hexadecimal "
+                     "number, 6 or 8 characters long.",
+                     str, *endptr);
+        return NULL;
+    }
+    return new_argb_from_hex(num, (len == 8));
+}
+
+static pmh_attr_value *new_attr_value()
+{
+    return (pmh_attr_value *)malloc(sizeof(pmh_attr_value));
+}
+
+static pmh_attr_font_styles *new_font_styles()
+{
+    pmh_attr_font_styles *ret = (pmh_attr_font_styles *)
+                                malloc(sizeof(pmh_attr_font_styles));
+    ret->italic = false;
+    ret->bold = false;
+    ret->underlined = false;
+    return ret;
+}
+
+static pmh_attr_font_size *new_font_size()
+{
+    pmh_attr_font_size *ret = (pmh_attr_font_size *)
+                              malloc(sizeof(pmh_attr_font_size));
+    ret->is_relative = false;
+    ret->size_pt = 0;
+    return ret;
+}
+
+static pmh_style_attribute *new_attr(char *name, pmh_attr_type type)
+{
+    pmh_style_attribute *attr = (pmh_style_attribute *)malloc(sizeof(pmh_style_attribute));
+    attr->name = strdup(name);
+    attr->type = type;
+    attr->next = NULL;
+    return attr;
+}
+
+static void free_style_attributes(pmh_style_attribute *list)
+{
+    pmh_style_attribute *cur = list;
+    while (cur != NULL)
+    {
+        if (cur->name != NULL)
+            free(cur->name);
+        if (cur->value != NULL)
+        {
+            if (cur->type == pmh_attr_type_foreground_color
+                || cur->type == pmh_attr_type_background_color
+                || cur->type == pmh_attr_type_caret_color
+                || cur->type == pmh_attr_type_strike_color)
+                free(cur->value->argb_color);
+            else if (cur->type == pmh_attr_type_font_family)
+                free(cur->value->font_family);
+            else if (cur->type == pmh_attr_type_font_style)
+                free(cur->value->font_styles);
+            else if (cur->type == pmh_attr_type_font_size_pt)
+                free(cur->value->font_size);
+            else if (cur->type == pmh_attr_type_other)
+                free(cur->value->string);
+            free(cur->value);
+        }
+        pmh_style_attribute *this = cur;
+        cur = cur->next;
+        free(this);
+    }
+}
+
+
+
+
+
+#define IF_ATTR_NAME(x) if (strcmp(x, name) == 0)
+pmh_attr_type pmh_attr_type_from_name(char *name)
+{
+    IF_ATTR_NAME("color") return pmh_attr_type_foreground_color;
+    else IF_ATTR_NAME("foreground") return pmh_attr_type_foreground_color;
+    else IF_ATTR_NAME("foreground-color") return pmh_attr_type_foreground_color;
+    else IF_ATTR_NAME("background") return pmh_attr_type_background_color;
+    else IF_ATTR_NAME("background-color") return pmh_attr_type_background_color;
+    else IF_ATTR_NAME("caret") return pmh_attr_type_caret_color;
+    else IF_ATTR_NAME("caret-color") return pmh_attr_type_caret_color;
+    else IF_ATTR_NAME("strike") return pmh_attr_type_strike_color;
+    else IF_ATTR_NAME("strike-color") return pmh_attr_type_strike_color;
+    else IF_ATTR_NAME("font-size") return pmh_attr_type_font_size_pt;
+    else IF_ATTR_NAME("font-family") return pmh_attr_type_font_family;
+    else IF_ATTR_NAME("font-style") return pmh_attr_type_font_style;
+    return pmh_attr_type_other;
+}
+
+char *pmh_attr_name_from_type(pmh_attr_type type)
+{
+    switch (type)
+    {
+        case pmh_attr_type_foreground_color:
+            return "foreground-color"; break;
+        case pmh_attr_type_background_color:
+            return "background-color"; break;
+        case pmh_attr_type_caret_color:
+            return "caret-color"; break;
+        case pmh_attr_type_strike_color:
+            return "strike-color"; break;
+        case pmh_attr_type_font_size_pt:
+            return "font-size"; break;
+        case pmh_attr_type_font_family:
+            return "font-family"; break;
+        case pmh_attr_type_font_style:
+            return "font-style"; break;
+        default:
+            return "unknown";
+    }
+}
+
+
+typedef struct multi_value
+{
+    char *value;
+    size_t length;
+    int line_number;
+    struct multi_value *next;
+} multi_value;
+
+static multi_value *split_multi_value(char *input, char separator)
+{
+    multi_value *head = NULL;
+    multi_value *tail = NULL;
+    
+    char *c = input;
+    while (*c != '\0')
+    {
+        size_t i;
+        for (i = 0; (*(c+i) != '\0' && *(c+i) != separator); i++);
+        
+        multi_value *mv = (multi_value *)malloc(sizeof(multi_value));
+        mv->value = (char *)malloc(sizeof(char)*i + 1);
+        mv->length = i;
+        mv->line_number = 0;
+        mv->next = NULL;
+        *mv->value = '\0';
+        strncat(mv->value, c, i);
+        
+        if (head == NULL) {
+            head = mv;
+            tail = mv;
+        } else {
+            tail->next = mv;
+            tail = mv;
+        }
+        
+        if (*(c+i) == separator)
+            i++;
+        c += i;
+    }
+    
+    return head;
+}
+
+static void free_multi_value(multi_value *val)
+{
+    multi_value *cur = val;
+    while (cur != NULL)
+    {
+        multi_value *this = cur;
+        multi_value *next_cur = cur->next;
+        free(this->value);
+        free(this);
+        cur = next_cur;
+    }
+}
+
+
+
+
+#define EQUALS(a,b) (strcmp(a, b) == 0)
+
+static pmh_style_attribute *interpret_attributes(style_parser_data *p_data,
+                                                 pmh_element_type lang_element_type,
+                                                 raw_attribute *raw_attributes)
+{
+    pmh_style_attribute *attrs = NULL;
+    
+    raw_attribute *cur = raw_attributes;
+    while (cur != NULL)
+    {
+        pmh_attr_type atype = pmh_attr_type_from_name(cur->name);
+        pmh_style_attribute *attr = new_attr(cur->name, atype);
+        attr->lang_element_type = lang_element_type;
+        attr->value = new_attr_value();
+        
+        if (atype == pmh_attr_type_foreground_color
+            || atype == pmh_attr_type_background_color
+            || atype == pmh_attr_type_caret_color
+            || atype == pmh_attr_type_strike_color)
+        {
+            char *hexstr = trim_str(cur->value);
+            // new_argb_from_hex_str() reports conversion errors
+            attr->value->argb_color =
+                new_argb_from_hex_str(p_data, cur->line_number, hexstr);
+            if (attr->value->argb_color == NULL) {
+                free_style_attributes(attr);
+                attr = NULL;
+            }
+        }
+        else if (atype == pmh_attr_type_font_size_pt)
+        {
+            pmh_attr_font_size *fs = new_font_size();
+            attr->value->font_size = fs;
+            
+            char *trimmed_value = trim_str_dup(cur->value);
+            
+            fs->is_relative = (*trimmed_value == '+' || *trimmed_value == '-');
+            char *endptr = NULL;
+            fs->size_pt = (int)strtol(cur->value, &endptr, 10);
+            if (endptr == cur->value) {
+                report_error(p_data, cur->line_number,
+                             "Value '%s' is invalid for attribute '%s'",
+                             cur->value, cur->name);
+                free_style_attributes(attr);
+                attr = NULL;
+            }
+            
+            free(trimmed_value);
+        }
+        else if (atype == pmh_attr_type_font_family)
+        {
+            attr->value->font_family = trim_str_dup(cur->value);
+        }
+        else if (atype == pmh_attr_type_font_style)
+        {
+            attr->value->font_styles = new_font_styles();
+            multi_value *values = split_multi_value(cur->value, ',');
+            multi_value *value_cur = values;
+            while (value_cur != NULL)
+            {
+                char *standardized_value = standardize_str(value_cur->value);
+                
+                if (EQUALS(standardized_value, "italic"))
+                    attr->value->font_styles->italic = true;
+                else if (EQUALS(standardized_value, "bold"))
+                    attr->value->font_styles->bold = true;
+                else if (EQUALS(standardized_value, "underlined"))
+                    attr->value->font_styles->underlined = true;
+                else {
+                    report_error(p_data, cur->line_number,
+                                 "Value '%s' is invalid for attribute '%s'",
+                                 standardized_value, cur->name);
+                }
+                
+                free(standardized_value);
+                value_cur = value_cur->next;
+            }
+            free_multi_value(values);
+        }
+        else if (atype == pmh_attr_type_other)
+        {
+            attr->value->string = trim_str_dup(cur->value);
+        }
+        
+        if (attr != NULL) {
+            // add to linked list
+            attr->next = attrs;
+            attrs = attr;
+        }
+        
+        cur = cur->next;
+    }
+    
+    return attrs;
+}
+
+
+static void interpret_and_add_style(style_parser_data *p_data,
+                                    char *style_rule_name,
+                                    int style_rule_line_number,
+                                    raw_attribute *raw_attributes)
+{
+    bool isEditorType = false;
+    bool isCurrentLineType = false;
+    bool isSelectionType = false;
+    pmh_element_type type = pmh_element_type_from_name(style_rule_name);
+    if (type == pmh_NO_TYPE)
+    {
+        if (EQUALS(style_rule_name, "editor"))
+            isEditorType = true, type = pmh_NO_TYPE;
+        else if (EQUALS(style_rule_name, "editor-current-line"))
+            isCurrentLineType = true, type = pmh_NO_TYPE;
+        else if (EQUALS(style_rule_name, "editor-selection"))
+            isSelectionType = true, type = pmh_NO_TYPE;
+        else {
+            report_error(p_data, style_rule_line_number,
+                "Style rule '%s' is not a language element type name or "
+                "one of the following: 'editor', 'editor-current-line', "
+                "'editor-selection'",
+                style_rule_name);
+            return;
+        }
+    }
+    pmh_style_attribute *attrs = interpret_attributes(p_data, type, raw_attributes);
+    if (isEditorType)
+        p_data->styles->editor_styles = attrs;
+    else if (isCurrentLineType)
+        p_data->styles->editor_current_line_styles = attrs;
+    else if (isSelectionType)
+        p_data->styles->editor_selection_styles = attrs;
+    else
+        p_data->styles->element_styles[(p_data->styles_pos)++] = attrs;
+}
+
+
+
+
+
+
+
+static bool char_is_whitespace(char c)
+{
+    return (c == ' ' || c == '\t');
+}
+
+static bool char_begins_linecomment(char c)
+{
+    return (c == '#');
+}
+
+static bool line_is_comment(multi_value *line)
+{
+    char *c;
+    for (c = line->value; *c != '\0'; c++)
+    {
+        if (!char_is_whitespace(*c))
+            return char_begins_linecomment(*c);
+    }
+    return false;
+}
+
+static bool line_is_empty(multi_value *line)
+{
+    char *c;
+    for (c = line->value; *c != '\0'; c++)
+    {
+        if (!char_is_whitespace(*c))
+            return false;
+    }
+    return true;
+}
+
+
+
+typedef struct block
+{
+    multi_value *lines;
+    struct block *next;
+} block;
+
+static block *new_block()
+{
+    block *ret = (block *)malloc(sizeof(block));
+    ret->next = NULL;
+    ret->lines = NULL;
+    return ret;
+}
+
+static void free_blocks(block *val)
+{
+    block *cur = val;
+    while (cur != NULL)
+    {
+        block *this = cur;
+        block *next = this->next;
+        free_multi_value(this->lines);
+        free(this);
+        cur = next;
+    }
+}
+
+static block *get_blocks(char *input)
+{
+    block *head = NULL;
+    block *tail = NULL;
+    block *current_block = NULL;
+    
+    multi_value *discarded_lines = NULL;
+    
+    int line_number_counter = 1;
+    
+    multi_value *lines = split_multi_value(input, '\n');
+    multi_value *previous_line = NULL;
+    multi_value *line_cur = lines;
+    while (line_cur != NULL)
+    {
+        bool discard_line = false;
+        
+        line_cur->line_number = line_number_counter++;
+        
+        if (line_is_empty(line_cur))
+        {
+            discard_line = true;
+            
+            if (current_block != NULL)
+            {
+                // terminate block
+                if (tail != current_block)
+                    tail->next = current_block;
+                tail = current_block;
+                current_block = NULL;
+                previous_line->next = NULL;
+            }
+        }
+        else if (line_is_comment(line_cur))
+        {
+            // Do not discard (i.e. free()) comment lines within blocks:
+            if (current_block == NULL)
+                discard_line = true;
+        }
+        else
+        {
+            if (current_block == NULL)
+            {
+                // start block
+                current_block = new_block();
+                current_block->lines = line_cur;
+                if (previous_line != NULL)
+                    previous_line->next = NULL;
+            }
+            if (head == NULL) {
+                head = current_block;
+                tail = current_block;
+            }
+        }
+        
+        multi_value *next_cur = line_cur->next;
+        previous_line = (discard_line) ? NULL : line_cur;
+        
+        if (discard_line) {
+            line_cur->next = discarded_lines;
+            discarded_lines = line_cur;
+        }
+        
+        line_cur = next_cur;
+    }
+    
+    if (current_block != NULL && tail != current_block)
+        tail->next = current_block;
+    
+    free_multi_value(discarded_lines);
+    
+    return head;
+}
+
+
+#define ASSIGNMENT_OP_UITEXT        "':' or '='"
+#define IS_ASSIGNMENT_OP(c)         ((c) == ':' || (c) == '=')
+#define IS_STYLE_RULE_NAME_CHAR(c)  \
+    ( (c) != '\0' && !isspace(c) \
+      && !char_begins_linecomment(c) && !IS_ASSIGNMENT_OP(c) )
+#define IS_ATTRIBUTE_NAME_CHAR(c)  \
+    ( (c) != '\0' && !char_begins_linecomment(c) && !IS_ASSIGNMENT_OP(c) )
+#define IS_ATTRIBUTE_VALUE_CHAR(c)  \
+    ( (c) != '\0' && !char_begins_linecomment(c) )
+
+static char *get_style_rule_name(multi_value *line)
+{
+    char *str = line->value;
+    
+    // Scan past leading whitespace:
+    size_t start_index;
+    for (start_index = 0;
+         (*(str+start_index) != '\0' && isspace(*(str+start_index)));
+         start_index++);
+    
+    // Scan until style rule name characters end:
+    size_t value_end_index;
+    for (value_end_index = start_index;
+         IS_STYLE_RULE_NAME_CHAR(*(str + value_end_index));
+         value_end_index++);
+    
+    // Copy style rule name:
+    size_t value_len = value_end_index - start_index;
+    char *value = (char *)malloc(sizeof(char)*value_len + 1);
+    *value = '\0';
+    strncat(value, (str + start_index), value_len);
+    
+    return value;
+}
+
+static bool parse_attribute_line(style_parser_data *p_data, multi_value *line,
+                                 char **out_attr_name, char **out_attr_value)
+{
+    char *str = line->value;
+    
+    // Scan past leading whitespace:
+    size_t name_start_index;
+    for (name_start_index = 0;
+         ( *(str+name_start_index) != '\0' &&
+           isspace(*(str+name_start_index)) );
+         name_start_index++);
+    
+    // Scan until attribute name characters end:
+    size_t name_end_index;
+    for (name_end_index = name_start_index;
+         IS_ATTRIBUTE_NAME_CHAR(*(str + name_end_index));
+         name_end_index++);
+    // Scan backwards to trim trailing whitespace off:
+    while (name_start_index < name_end_index
+           && isspace(*(str + name_end_index - 1)))
+        name_end_index--;
+    
+    // Scan until just after the first assignment operator:
+    size_t assignment_end_index;
+    for (assignment_end_index = name_end_index;
+         ( *(str + assignment_end_index) != '\0' &&
+           !IS_ASSIGNMENT_OP(*(str + assignment_end_index)) );
+         assignment_end_index++);
+    
+    // Scan over the found assignment operator, or report error:
+    if (IS_ASSIGNMENT_OP(*(str + assignment_end_index)))
+        assignment_end_index++;
+    else
+    {
+        report_error(p_data, line->line_number,
+                     "Invalid attribute definition: str does not contain "
+                     "an assignment operator (%s): '%s'",
+                     ASSIGNMENT_OP_UITEXT, str);
+        return false;
+    }
+    
+    size_t value_start_index = assignment_end_index;
+    // Scan until attribute value characters end:
+    size_t value_end_index;
+    for (value_end_index = value_start_index;
+         IS_ATTRIBUTE_VALUE_CHAR(*(str + value_end_index));
+         value_end_index++);
+    
+    // Copy attribute name:
+    size_t name_len = name_end_index - name_start_index;
+    char *attr_name = (char *)malloc(sizeof(char)*name_len + 1);
+    *attr_name = '\0';
+    strncat(attr_name, (str + name_start_index), name_len);
+    *out_attr_name = attr_name;
+    
+    // Copy attribute value:
+    size_t attr_value_len = value_end_index - assignment_end_index;
+    char *attr_value_str = (char *)malloc(sizeof(char)*attr_value_len + 1);
+    *attr_value_str = '\0';
+    strncat(attr_value_str, (str + assignment_end_index), attr_value_len);
+    *out_attr_value = attr_value_str;
+    
+    return true;
+}
+
+
+#define HAS_UTF8_BOM(x)         ( ((*x & 0xFF) == 0xEF)\
+                                  && ((*(x+1) & 0xFF) == 0xBB)\
+                                  && ((*(x+2) & 0xFF) == 0xBF) )
+
+// - Removes UTF-8 BOM
+// - Standardizes line endings to \n
+static char *strcpy_preformat_style(char *str)
+{
+    char *new_str = (char *)malloc(sizeof(char) * strlen(str) + 1);
+    
+    char *c = str;
+    int i = 0;
+    
+    if (HAS_UTF8_BOM(c))
+        c += 3;
+    
+    while (*c != '\0')
+    {
+        if (*c == '\r' && *(c+1) == '\n')
+        {
+            *(new_str+i) = '\n';
+            i++;
+            c += 2;
+        }
+        else if (*c == '\r')
+        {
+            *(new_str+i) = '\n';
+            i++;
+            c++;
+        }
+        else
+        {
+            *(new_str+i) = *c;
+            i++;
+            c++;
+        }
+    }
+    *(new_str+i) = '\0';
+    
+    return new_str;
+}
+
+
+
+static void _sty_parse(style_parser_data *p_data)
+{
+    // We don't have to worry about leaking the original p_data->input;
+    // the user of the library is responsible for that:
+    p_data->input = strcpy_preformat_style(p_data->input);
+    
+    block *blocks = get_blocks(p_data->input);
+    
+    block *block_cur = blocks;
+    while (block_cur != NULL)
+    {
+        pmhsp_PRINTF("Block:\n");
+        multi_value *header_line = block_cur->lines;
+        if (header_line == NULL) {
+            block_cur = block_cur->next;
+            continue;
+        }
+        
+        pmhsp_PRINTF("  Head line (len %ld): '%s'\n",
+                     header_line->length, header_line->value);
+        char *style_rule_name = get_style_rule_name(header_line);
+        pmhsp_PRINTF("  Style rule name: '%s'\n", style_rule_name);
+        
+        multi_value *attr_line_cur = header_line->next;
+        if (attr_line_cur == NULL)
+            report_error(p_data, header_line->line_number,
+                         "No style attributes defined for style rule '%s'",
+                         style_rule_name);
+        
+        raw_attribute *attributes_head = NULL;
+        raw_attribute *attributes_tail = NULL;
+        
+        while (attr_line_cur != NULL)
+        {
+            if (line_is_comment(attr_line_cur))
+            {
+                attr_line_cur = attr_line_cur->next;
+                continue;
+            }
+            
+            pmhsp_PRINTF("  Attr line (len %ld): '%s'\n",
+                         attr_line_cur->length, attr_line_cur->value);
+            char *attr_name_str;
+            char *attr_value_str;
+            bool success = parse_attribute_line(p_data,
+                                                attr_line_cur,
+                                                &attr_name_str,
+                                                &attr_value_str);
+            if (success)
+            {
+                pmhsp_PRINTF("  Attr: '%s' Value: '%s'\n",
+                             attr_name_str, attr_value_str);
+                raw_attribute *attribute =
+                    new_raw_attribute(attr_name_str, attr_value_str,
+                                      attr_line_cur->line_number);
+                if (attributes_head == NULL) {
+                    attributes_head = attribute;
+                    attributes_tail = attribute;
+                } else {
+                    attributes_tail->next = attribute;
+                    attributes_tail = attribute;
+                }
+            }
+            
+            attr_line_cur = attr_line_cur->next;
+        }
+        
+        if (attributes_head != NULL)
+        {
+            interpret_and_add_style(p_data, style_rule_name,
+                                    header_line->line_number, attributes_head);
+            free_raw_attributes(attributes_head);
+        }
+        
+        free(style_rule_name);
+        
+        block_cur = block_cur->next;
+    }
+    
+    free_blocks(blocks);
+    free(p_data->input);
+}
+
+
+
+static pmh_style_collection *new_style_collection()
+{
+    pmh_style_collection *sc = (pmh_style_collection *)
+                               malloc(sizeof(pmh_style_collection));
+    
+    sc->element_styles = (pmh_style_attribute**)
+                         malloc(sizeof(pmh_style_attribute*)
+                                * pmh_NUM_LANG_TYPES);
+    int i;
+    for (i = 0; i < pmh_NUM_LANG_TYPES; i++)
+        sc->element_styles[i] = NULL;
+    
+    sc->editor_styles = NULL;
+    sc->editor_current_line_styles = NULL;
+    sc->editor_selection_styles = NULL;
+    
+    return sc;
+}
+
+void pmh_free_style_collection(pmh_style_collection *coll)
+{
+    free_style_attributes(coll->editor_styles);
+    free_style_attributes(coll->editor_current_line_styles);
+    free_style_attributes(coll->editor_selection_styles);
+    int i;
+    for (i = 0; i < pmh_NUM_LANG_TYPES; i++)
+        free_style_attributes(coll->element_styles[i]);
+    free(coll->element_styles);
+    free(coll);
+}
+
+static style_parser_data *new_style_parser_data(char *input)
+{
+    style_parser_data *p_data = (style_parser_data*)
+                                malloc(sizeof(style_parser_data));
+    p_data->input = input;
+    p_data->styles_pos = 0;
+    p_data->styles = new_style_collection();
+    return p_data;
+}
+
+pmh_style_collection *pmh_parse_styles(char *input,
+                                       void(*error_callback)(char*,int,void*),
+                                       void *error_callback_context)
+{
+    style_parser_data *p_data = new_style_parser_data(input);
+    p_data->error_callback = error_callback;
+    p_data->error_callback_context = error_callback_context;
+    
+    _sty_parse(p_data);
+    
+    pmh_style_collection *ret = p_data->styles;
+    free(p_data);
+    return ret;
+}
+
+

+ 148 - 0
utils/peg-highlight/pmh_styleparser.h

@@ -0,0 +1,148 @@
+/* PEG Markdown Highlight
+ * Copyright 2011-2016 Ali Rantakari -- http://hasseg.org
+ * Licensed under the GPL2+ and MIT licenses (see LICENSE for more info).
+ * 
+ * pmh_styleparser.h
+ * 
+ * Public interface of a parser for custom syntax highlighting stylesheets.
+ */
+
+/** \file
+* \brief Style parser public interface.
+*/
+
+#include "pmh_definitions.h"
+#include <stdbool.h>
+
+/**
+* \brief Color (ARGB) attribute value.
+* 
+* All values are 0-255.
+*/
+typedef struct
+{
+    int red;    /**< Red color component (0-255) */
+    int green;  /**< Green color component (0-255) */
+    int blue;   /**< Blue color component (0-255) */
+    int alpha;  /**< Alpha (opacity) color component (0-255) */
+} pmh_attr_argb_color;
+
+/** \brief Font style attribute value. */
+typedef struct
+{
+    bool italic;
+    bool bold;
+    bool underlined;
+} pmh_attr_font_styles;
+
+/** \brief Font size attribute value. */
+typedef struct
+{
+    int size_pt;        /**< The font point size */
+    bool is_relative;   /**< Whether the size is relative (i.e. size_pt points
+                             larger than the default font) */
+} pmh_attr_font_size;
+
+/** \brief Style attribute types. */
+typedef enum
+{
+    pmh_attr_type_foreground_color, /**< Foreground color */
+    pmh_attr_type_background_color, /**< Background color */
+    pmh_attr_type_caret_color,      /**< Caret (insertion point) color */
+    pmh_attr_type_font_size_pt,     /**< Font size (in points) */
+    pmh_attr_type_font_family,      /**< Font family */
+    pmh_attr_type_font_style,       /**< Font style */
+    pmh_attr_type_strike_color,     /**< Strike-through color */
+    pmh_attr_type_other             /**< Arbitrary custom attribute */
+} pmh_attr_type;
+
+/**
+* \brief Style attribute value.
+* 
+* Determine which member to access in this union based on the
+* 'type' value of the pmh_style_attribute.
+* 
+* \sa pmh_style_attribute
+*/
+typedef union
+{
+    pmh_attr_argb_color *argb_color;    /**< ARGB color */
+    pmh_attr_font_styles *font_styles;  /**< Font styles */
+    pmh_attr_font_size *font_size;      /**< Font size */
+    char *font_family;                  /**< Font family */
+    char *string;                       /**< Arbitrary custom string value
+                                             (use this if the attribute's type
+                                             is pmh_attr_type_other) */
+} pmh_attr_value;
+
+/** \brief Style attribute. */
+typedef struct pmh_style_attribute
+{
+    pmh_element_type lang_element_type; /**< The Markdown language element this
+                                             style applies to */
+    pmh_attr_type type;                 /**< The type of the attribute */
+    char *name;                         /**< The name of the attribute (if type
+                                             is pmh_attr_type_other, you can
+                                             use this value to determine what
+                                             the attribute is) */
+    pmh_attr_value *value;              /**< The value of the attribute */
+    struct pmh_style_attribute *next;   /**< Next attribute in linked list */
+} pmh_style_attribute;
+
+/** \brief Collection of styles. */
+typedef struct
+{
+    /** Styles that apply to the editor in general */
+    pmh_style_attribute *editor_styles;
+    
+    /** Styles that apply to the line in the editor where the caret (insertion
+        point) resides */
+    pmh_style_attribute *editor_current_line_styles;
+    
+    /** Styles that apply to the range of selected text in the editor */
+    pmh_style_attribute *editor_selection_styles;
+    
+    /** Styles that apply to specific Markdown language elements */
+    pmh_style_attribute **element_styles;
+} pmh_style_collection;
+
+
+/**
+* \brief Parse stylesheet string, return style collection
+* 
+* \param[in] input                   The stylesheet string to parse.
+* \param[in] error_callback          Callback function to be called when errors
+*                                    occur during parsing. The first argument
+*                                    to the callback function is the error
+*                                    message and the second one the line number
+*                                    in the original input where the error
+*                                    occurred. The last argument will always
+*                                    get the value you pass in for the
+*                                    error_callback_context argument to this
+*                                    function.
+*                                    Pass in NULL to suppress error reporting.
+* \param[in] error_callback_context  Arbitrary context pointer for the error
+*                                    callback function; will be passed in as
+*                                    the last argument to error_callback.
+* 
+* \return A pmh_style_collection. You must pass this value to
+*         pmh_free_style_collection() when it's not needed anymore.
+*/
+pmh_style_collection *pmh_parse_styles(char *input,
+                                       void(*error_callback)(char*,int,void*),
+                                       void *error_callback_context);
+
+/**
+* \brief Free a pmh_style_collection.
+* 
+* Frees a pmh_style_collection value returned by pmh_parse_styles().
+* 
+* \param[in] collection  The collection to free.
+*/
+void pmh_free_style_collection(pmh_style_collection *collection);
+
+
+char *pmh_attr_name_from_type(pmh_attr_type type);
+
+pmh_attr_type pmh_attr_type_from_name(char *name);
+

+ 8 - 0
utils/peg-highlight/styles/error.style

@@ -0,0 +1,8 @@
+NONEXISTENT_TYPE
+x: 3
+
+STRONG
+font-style: funkadelic, bold, snazzy
+foreground: 13bx12
+background: 5
+

+ 87 - 0
utils/peg-highlight/styles/fontsizes.style

@@ -0,0 +1,87 @@
+# Styles using 'Solarized' color scheme
+# by Ethan Schoonover: http://ethanschoonover.com/solarized
+# 
+# (dark background version)
+
+editor
+foreground: 93a1a1 # base1
+background: 002b36 # base03
+caret: ffffff
+font-size: 13
+
+H1
+foreground: 6c71c4 # violet
+font-style: bold
+font-size: +6
+
+H2
+foreground: 6c71c4 # violet
+font-style: bold
+font-size: +5
+
+H3
+foreground: 6c71c4 # violet
+font-size: +4
+
+H4
+foreground: 268bd2 # blue
+font-size: +3
+
+H5
+foreground: 268bd2 # blue
+font-size: +2
+
+H6
+foreground: 268bd2 # blue
+font-size: +1
+
+HRULE
+foreground: 586e75 # base01
+
+LIST_BULLET
+foreground: b58900 # yellow
+
+LIST_ENUMERATOR
+foreground: b58900 # yellow
+
+LINK
+foreground: 2aa198 # cyan
+
+AUTO_LINK_URL
+foreground: 2aa198 # cyan
+
+AUTO_LINK_EMAIL
+foreground: 2aa198 # cyan
+
+IMAGE
+foreground: d33682 # magenta
+
+REFERENCE
+foreground: 80b58900 # yellow, reduced alpha
+font-size: -2
+
+CODE
+foreground: 859900 # green
+
+EMPH
+foreground: cb4b16 # orange
+font-style: italic
+
+STRONG
+foreground: dc322f # red
+font-style: bold
+
+HTML_ENTITY
+foreground: 6c71c4 # violet
+
+COMMENT
+foreground: 93a1a1 # base1
+
+VERBATIM
+foreground: 859900 # green
+
+BLOCKQUOTE
+foreground: d33682 # magenta
+
+STRIKE
+strike-color: 93a1a1 # base1

+ 1 - 0
utils/peg-highlight/styles/macoslineseparator.style

@@ -0,0 +1 @@
+# linecomment

editor # comment
    foreground : 13ff13
    background : 000000 # comment

# linecomment
STRONG:

EMPH=
    # comment
    foreground: 00ff00
comment asd
    background: AB0000ff

STRONG  : 
    dog: 1  # something
    cat: 4
    font-style: underlined, Italic , BoLD #hi, hello
    font-size: 14pt
    font-family: Courier New, Times

# linecomment
BOO
    x: 3

editor-selection:
    foreground: abcdef
    background: abcdef

editor-current-line:
    background: ffffff


+ 22 - 0
utils/peg-highlight/styles/playground.style

@@ -0,0 +1,22 @@
+editor :
+    foreground : 13ff13
+    background : 000000
+    caret: ffffff
+
+EMPH
+    font-style: italic
+
+STRONG
+    font-style: bold
+
+LINK
+    font-style: underlined
+
+editor-selection:
+    foreground: ff0000
+    background: eeeeee
+    font-style: underlined
+
+editor-current-line:
+    background: ffffff
+

+ 79 - 0
utils/peg-highlight/styles/solarized-dark.style

@@ -0,0 +1,79 @@
+# Styles using 'Solarized' color scheme
+# by Ethan Schoonover: http://ethanschoonover.com/solarized
+# 
+# (dark background version)
+
+editor
+foreground: 93a1a1 # base1
+background: 002b36 # base03
+caret: ffffff
+
+H1
+foreground: 6c71c4 # violet
+font-style: bold
+
+H2
+foreground: 6c71c4 # violet
+font-style: bold
+
+H3
+foreground: 6c71c4 # violet
+
+H4
+foreground: 268bd2 # blue
+
+H5
+foreground: 268bd2 # blue
+
+H6
+foreground: 268bd2 # blue
+
+HRULE
+foreground: 586e75 # base01
+
+LIST_BULLET
+foreground: b58900 # yellow
+
+LIST_ENUMERATOR
+foreground: b58900 # yellow
+
+LINK
+foreground: 2aa198 # cyan
+
+AUTO_LINK_URL
+foreground: 2aa198 # cyan
+
+AUTO_LINK_EMAIL
+foreground: 2aa198 # cyan
+
+IMAGE
+foreground: d33682 # magenta
+
+REFERENCE
+foreground: 80b58900 # yellow, reduced alpha
+
+CODE
+foreground: 859900 # green
+
+EMPH
+foreground: cb4b16 # orange
+font-style: italic
+
+STRONG
+foreground: dc322f # red
+font-style: bold
+
+HTML_ENTITY
+foreground: 6c71c4 # violet
+
+COMMENT
+foreground: 93a1a1 # base1
+
+VERBATIM
+foreground: 859900 # green
+
+BLOCKQUOTE
+foreground: d33682 # magenta
+
+STRIKE
+strike-color: 93a1a1 # base1

+ 80 - 0
utils/peg-highlight/styles/solarized-light.style

@@ -0,0 +1,80 @@
+# Styles using 'Solarized' color scheme
+# by Ethan Schoonover: http://ethanschoonover.com/solarized
+# 
+# (light background version)
+
+editor
+foreground: 586e75 # base01
+background: fdf6e3 # base3
+caret: 000000
+
+H1
+foreground: 6c71c4 # violet
+font-style: bold
+
+H2
+foreground: 6c71c4 # violet
+font-style: bold
+
+H3
+foreground: 6c71c4 # violet
+
+H4
+foreground: 268bd2 # blue
+
+H5
+foreground: 268bd2 # blue
+
+H6
+foreground: 268bd2 # blue
+
+HRULE
+foreground: 586e75 # base01
+
+LIST_BULLET
+foreground: b58900 # yellow
+
+LIST_ENUMERATOR
+foreground: b58900 # yellow
+
+LINK
+foreground: 2aa198 # cyan
+
+AUTO_LINK_URL
+foreground: 2aa198 # cyan
+
+AUTO_LINK_EMAIL
+foreground: 2aa198 # cyan
+
+IMAGE
+foreground: d33682 # magenta
+
+REFERENCE
+foreground: 80b58900 # yellow, reduced alpha
+
+CODE
+foreground: 859900 # green
+
+EMPH
+foreground: cb4b16 # orange
+font-style: italic
+
+STRONG
+foreground: dc322f # red
+font-style: bold
+
+HTML_ENTITY
+foreground: 6c71c4 # violet
+
+COMMENT
+foreground: 93a1a1 # base1
+
+VERBATIM
+foreground: 859900 # green
+
+BLOCKQUOTE
+foreground: d33682 # magenta
+
+STRIKE
+strike-color: 586e75 # base01
+

+ 33 - 0
utils/peg-highlight/styles/teststyle.style

@@ -0,0 +1,33 @@
+# linecomment
+
+editor # comment
+    foreground : 13ff13
+    background : 000000 # comment
+
+# linecomment
+STRONG:
+
+EMPH=
+    # comment
+    foreground: 00ff00
+comment asd
+    background: AB0000ff
+
+STRONG  : 
+    dog: 1  # something
+    cat: 4
+    font-style: underlined, Italic , BoLD #hi, hello
+    font-size: 14pt
+    font-family: Courier New, Times
+
+# linecomment
+BOO
+    x: 3
+
+editor-selection:
+    foreground: abcdef
+    background: abcdef
+
+editor-current-line:
+    background: ffffff
+

+ 33 - 0
utils/peg-highlight/styles/winlineseparator.style

@@ -0,0 +1,33 @@
+# linecomment
+
+editor # comment
+    foreground : 13ff13
+    background : 000000 # comment
+
+# linecomment
+STRONG:
+
+EMPH=
+    # comment
+    foreground: 00ff00
+comment asd
+    background: AB0000ff
+
+STRONG  : 
+    dog: 1  # something
+    cat: 4
+    font-style: underlined, Italic , BoLD #hi, hello
+    font-size: 14pt
+    font-family: Courier New, Times
+
+# linecomment
+BOO
+    x: 3
+
+editor-selection:
+    foreground: abcdef
+    background: abcdef
+
+editor-current-line:
+    background: ffffff
+

+ 199 - 0
utils/peg-highlight/stylesheet_syntax.md

@@ -0,0 +1,199 @@
+
+The Syntax of PEG Markdown Highlight Stylesheets
+================================================
+
+[PEG Markdown Highlight][pmh] includes a parser for stylesheets that define how different Markdown language elements are to be highlighted. This document describes the syntax of these stylesheets.
+
+[pmh]: http://hasseg.org/peg-markdown-highlight/
+
+
+Example
+-------
+
+Here is a quick, simple example of a stylesheet:
+
+<style>
+.codetable { border-collapse: collapse; }
+.codetable .left { text-align: right; padding-right: 10px; }
+.codetable .right { text-align: left; padding-left: 10px; }
+.codetable .content { font-family: monospace; background: #eee; padding: 0 5px; }
+.codetable .comment { color: #174EB3; }
+.codetable .rule { color: #491B8F; }
+.codetable .attrname { color: #48B317; }
+.codetable .attrvalue { color: #A65C1F; }
+</style>
+
+<table class="codetable">
+<tr>
+    <td class="left"></td>
+    <td class="content"># The first comment lines</td>
+    <td class="right"></td>
+</tr>
+<tr>
+    <td class="left"></td>
+    <td class="content"># describe the stylesheet.</td>
+    <td class="right"></td>
+</tr>
+<tr>
+    <td class="left"></td>
+    <td class="content">&nbsp;</td>
+    <td class="right"></td>
+</tr>
+<tr>
+    <td class="left"><span class="rule">Style rule &rarr;</span></td>
+    <td class="content"><span class="rule">editor:</span></td>
+    <td class="right"></td>
+</tr>
+<tr>
+    <td class="left"></td>
+    <td class="content">&nbsp;&nbsp;foreground: ff0000 <span class="comment"># red text</span></td>
+    <td class="right"><span class="comment">&larr; Comment</span></td>
+</tr>
+<tr>
+    <td class="left"><span class="attrname">Attribute name &rarr;</span></td>
+    <td class="content">&nbsp;&nbsp;<span class="attrname">font-family</span>: <span class="attrvalue">Consolas</span></td>
+    <td class="right"><span class="attrvalue">&larr; Attribute value</span></td>
+</tr>
+<tr>
+    <td class="left"></td>
+    <td class="content">&nbsp;</td>
+    <td class="right"></td>
+</tr>
+<tr>
+    <td class="left"></td>
+    <td class="content">EMPH:</td>
+    <td class="right"></td>
+</tr>
+<tr>
+    <td class="left"></td>
+    <td class="content">&nbsp;&nbsp;font-size: 14</td>
+    <td class="right"></td>
+</tr>
+<tr>
+    <td class="left"></td>
+    <td class="content">&nbsp;&nbsp;font-style: bold, underlined</td>
+    <td class="right"></td>
+</tr>
+</table>
+
+
+Style Rules
+-----------
+
+A stylesheet is composed of one or more *rules*. Rules are separated from each other by **empty lines** like so:
+
+    H2:
+    foreground: ff0000
+    
+    H3:
+    foreground: 00ff00
+
+Each begins with the ***name* of the rule**, which is always on its own line, and may be one of the following:
+
+- **`editor`**: Styles that apply to the whole document/editor
+- **`editor-current-line`**: Styles that apply to the current line in the editor (i.e. the line where the caret is)
+- **`editor-selection`**: Styles that apply to the selected range in the editor when the user makes a selection in the text
+- A Markdown element type (like `EMPH`, `REFERENCE` or `H1`): Styles that apply to occurrences of that particular element. The supported element types are:
+    - **`LINK`:** Explicit link (like `[click here][ref]`)
+    - **`AUTO_LINK_URL`:** Implicit URL link (like `<http://google.com>`)
+    - **`AUTO_LINK_EMAIL`:** Implicit email link (like `<[email protected]>`)
+    - **`IMAGE`:** Image definition
+    - **`REFERENCE`:** Reference (like `[id]: http://www.google.com`)
+    - **`CODE`:** Inline code
+    - **`EMPH`:** Emphasized text
+    - **`STRONG`:** Strong text
+    - **`LIST_BULLET`:** Bullet for an unordered list item
+    - **`LIST_ENUMERATOR`:** Enumerator for an ordered list item
+    - **`H1`:** Header, level 1
+    - **`H2`:** Header, level 2
+    - **`H3`:** Header, level 3
+    - **`H4`:** Header, level 4
+    - **`H5`:** Header, level 5
+    - **`H6`:** Header, level 6
+    - **`BLOCKQUOTE`:** Blockquote marker
+    - **`VERBATIM`:** Block of code
+    - **`HRULE`:** Horizontal rule
+    - **`HTML`:** HTML tag
+    - **`HTML_ENTITY`:** HTML special entity definition (like `&hellip;`)
+    - **`HTMLBLOCK`:** Block of HTML
+    - **`COMMENT`:** (HTML) Comment
+    - **`NOTE`:** Note
+    - **`STRIKE`:** Strike-through
+
+The name may be optionally followed by an assignment operator (either `:` or `=`):
+
+    H1:
+    foreground: ff00ff
+    
+    H2 =
+    foreground: ff0000
+    
+    H3
+    foreground: 00ff00
+
+The **order of style rules is significant**; it defines the order in which different language elements should be highlighted. *(Of course applications that use PEG Markdown Highlight and the style parser may disregard this and highlight elements in whatever order they desire.)*
+
+After the name of the rule, there can be one or more *attributes*.
+
+
+Style Attributes
+----------------
+
+Attribute assignments are each on their own line, and they consist of the *name* of the attribute as well as the *value* assigned to it. An assignment operator (either `:` or `=`) separates the name from the value:
+
+    attribute-name: value
+    attribute-name= value
+
+Attribute assignment lines **may be indented**.
+
+### Attribute Names and Types
+
+The following is a list of the names of predefined attributes, and the values they may be assigned:
+
+- `foreground-color` *(aliases: `foreground` and `color`)*
+    - See the *Color Attribute Values* subsection for information about valid values for this attribute.
+- `background-color` *(alias: `background`)*
+    - See the *Color Attribute Values* subsection for information about valid values for this attribute.
+- `caret-color` *(alias: `caret`)*
+    - See the *Color Attribute Values* subsection for information about valid values for this attribute.
+- `strike-color` *(alias: `strike`)*
+    - See the *Color Attribute Values* subsection for information about valid values for this attribute.
+- `font-size`
+    - An integer value for the font size, *in points* (i.e. not in pixels). The number may have a textual suffix such as `pt`.
+    - If the value begins with `+` or `-`, it is considered *relative* to some base font size (as defined by the host application). For example, the value `3` defines the font size as 3 (absolute) while `+3` defines it as +3 (relative), i.e. 3 point sizes larger than the base font size.
+- `font-family`
+    - A comma-separated list of one or more arbitrary font family names. *(It is up to the application that uses the PEG Markdown Highlight library to resolve this string to actual fonts on the system.)*
+- `font-style`
+    - A comma-separated list of one or more of the following:
+        - `italic`
+        - `bold`
+        - `underlined`
+
+Applications may also include support for any **custom attribute names and values** they desire &mdash; attributes other than the ones listed above will be included in the style parser results, with their values stored as strings.
+
+
+## Color Attribute Values
+
+Colors can be specified either in **RGB** (red, green, blue) or **ARGB** (alpha, red, green, blue) formats. In both, each component is a two-character hexadecimal value (from `00` to `FF`):
+
+    foreground: ff00ee  # red = ff, green = 00, blue = ee (and implicitly, alpha = ff)
+    background: 99ff00ee  # alpha = 99, red = ff, green = 00, blue = ee
+
+
+Comments
+--------
+
+Each line in a stylesheet may have a comment. The `#` character begins a line comment that continues until the end of the line:
+
+    # this line has only this comment
+    H1:  # this line has a style rule name and then a comment
+    foreground: ff0000  # this line has an attribute and then a comment
+
+
+
+
+
+
+
+
+

+ 4 - 0
veditor.cpp

@@ -8,6 +8,7 @@
 #include "vnote.h"
 #include "utils/vutils.h"
 #include "vpreviewpage.h"
+#include "hgmarkdownhighlighter.h"
 
 VEditor::VEditor(const QString &path, const QString &name, bool modifiable,
                  QWidget *parent)
@@ -18,6 +19,7 @@ VEditor::VEditor(const QString &path, const QString &name, bool modifiable,
     noteFile = new VNoteFile(path, name, fileText, docType, modifiable);
 
     isEditMode = false;
+    mdHighlighter = NULL;
 
     setupUI();
 
@@ -38,6 +40,8 @@ void VEditor::setupUI()
     case DocType::Markdown:
         setupMarkdownPreview();
         textBrowser = NULL;
+
+        mdHighlighter = new HGMarkdownHighlighter(textEditor->document(), 500);
         break;
 
     case DocType::Html:

+ 2 - 0
veditor.h

@@ -10,6 +10,7 @@
 class QTextBrowser;
 class VEdit;
 class QWebEngineView;
+class HGMarkdownHighlighter;
 
 class VEditor : public QStackedWidget
 {
@@ -38,6 +39,7 @@ private:
     VEdit *textEditor;
     QWebEngineView *webPreviewer;
     VDocument document;
+    HGMarkdownHighlighter *mdHighlighter;
 };
 
 #endif // VEDITOR_H