diff --git a/CMark.hsc b/CMark.hsc new file mode 100644 --- /dev/null +++ b/CMark.hsc @@ -0,0 +1,268 @@ +{-# LANGUAGE CPP, ForeignFunctionInterface, GeneralizedNewtypeDeriving, + DeriveGeneric, DeriveDataTypeable, FlexibleContexts #-} + +module CMark ( + Node(..) + , NodeType(..) + , PosInfo(..) + , DelimType(..) + , ListType(..) + , Tightness + , Url + , Title + , Level + , Info + , CMarkOption + , markdownToHtml + , parseDocument + , optSourcePos + , optNormalize + , optHardBreaks + , optSmart + ) where + +import Foreign +import Foreign.C.Types +import Foreign.C.String (CString) +import qualified System.IO.Unsafe as Unsafe +import GHC.Generics (Generic) +import Data.Generics (Data, Typeable) +import Data.Bits ( (.|.) ) +import Data.Text (Text, pack, empty) +import qualified Data.Text.Foreign as TF + +#include + +type NodePtr = Ptr () + +data Node = Node (Maybe PosInfo) NodeType [Node] + deriving (Show, Read, Eq, Ord, Typeable, Data, Generic) + +data DelimType = + PERIOD_DELIM + | PAREN_DELIM + deriving (Show, Read, Eq, Ord, Typeable, Data, Generic) + +data ListType = + BULLET_LIST + | ORDERED_LIST + deriving (Show, Read, Eq, Ord, Typeable, Data, Generic) + +type Url = Text + +type Title = Text + +type Level = Int + +type Info = Text + +data Tightness = TIGHT | LOOSE + deriving (Show, Read, Eq, Ord, Typeable, Data, Generic) + +data NodeType = + DOCUMENT + | HRULE + | PARAGRAPH + | BLOCK_QUOTE + | HTML Text + | CODE_BLOCK Info Text + | HEADER Level + | LIST ListType Tightness + | ITEM + | TEXT Text + | SOFTBREAK + | LINEBREAK + | INLINE_HTML Text + | CODE Text + | EMPH + | STRONG + | LINK Url Title + | IMAGE Url Title + deriving (Show, Read, Eq, Ord, Typeable, Data, Generic) + +data PosInfo = PosInfo{ startLine :: Int + , startColumn :: Int + , endLine :: Int + , endColumn :: Int + } + deriving (Show, Read, Eq, Ord, Typeable, Data, Generic) + +-- | A type for PCRE compile-time options. These are newtyped CInts, +-- which can be bitwise-or'd together, using '(Data.Bits..|.)' +newtype CMarkOption = CMarkOption { unCMarkOption :: CInt } + +-- | Combine a list of options into a single option, using bitwise or. +combineOptions :: [CMarkOption] -> CInt +combineOptions = foldr ((.|.) . unCMarkOption) 0 + +-- Include a @data-sourcepos@ attribute on block elements. +optSourcePos :: CMarkOption +optSourcePos = CMarkOption #const CMARK_OPT_SOURCEPOS + +-- Render @softbreak@ elements as hard line breaks. +optHardBreaks :: CMarkOption +optHardBreaks = CMarkOption #const CMARK_OPT_HARDBREAKS + +-- Normalize the document by consolidating adjacent text nodes. +optNormalize :: CMarkOption +optNormalize = CMarkOption #const CMARK_OPT_NORMALIZE + +-- Convert straight quotes to curly, @---@ to em-dash, @--@ to en-dash. +optSmart :: CMarkOption +optSmart = CMarkOption #const CMARK_OPT_SMART + +ptrToNodeType :: NodePtr -> NodeType +ptrToNodeType ptr = + case (c_cmark_node_get_type ptr) of + #const CMARK_NODE_DOCUMENT + -> DOCUMENT + #const CMARK_NODE_HRULE + -> HRULE + #const CMARK_NODE_PARAGRAPH + -> PARAGRAPH + #const CMARK_NODE_BLOCK_QUOTE + -> BLOCK_QUOTE + #const CMARK_NODE_HTML + -> HTML literal + #const CMARK_NODE_CODE_BLOCK + -> CODE_BLOCK info literal + #const CMARK_NODE_LIST + -> LIST listType tightness + #const CMARK_NODE_ITEM + -> ITEM + #const CMARK_NODE_HEADER + -> HEADER level + #const CMARK_NODE_EMPH + -> EMPH + #const CMARK_NODE_STRONG + -> STRONG + #const CMARK_NODE_LINK + -> LINK url title + #const CMARK_NODE_IMAGE + -> IMAGE url title + #const CMARK_NODE_TEXT + -> TEXT literal + #const CMARK_NODE_CODE + -> CODE literal + #const CMARK_NODE_INLINE_HTML + -> INLINE_HTML literal + #const CMARK_NODE_SOFTBREAK + -> SOFTBREAK + #const CMARK_NODE_LINEBREAK + -> LINEBREAK + where literal = peekCString $ c_cmark_node_get_literal ptr + level = c_cmark_node_get_header_level ptr + listType = case c_cmark_node_get_list_type ptr of + (#const CMARK_ORDERED_LIST) -> ORDERED_LIST + (#const CMARK_BULLET_LIST) -> BULLET_LIST + _ -> BULLET_LIST + delimType = case c_cmark_node_get_list_delim ptr of + (#const CMARK_PERIOD_DELIM) -> PERIOD_DELIM + (#const CMARK_PAREN_DELIM) -> PAREN_DELIM + _ -> PERIOD_DELIM + tightness = case c_cmark_node_get_list_type ptr of + 1 -> TIGHT + _ -> LOOSE + url = peekCString $ c_cmark_node_get_url ptr + title = peekCString $ c_cmark_node_get_title ptr + info = peekCString $ c_cmark_node_get_fence_info ptr + +getPosInfo :: NodePtr -> Maybe PosInfo +getPosInfo ptr = + case (c_cmark_node_get_start_line ptr, + c_cmark_node_get_start_column ptr, + c_cmark_node_get_end_line ptr, + c_cmark_node_get_end_column ptr) of + (0, 0, 0, 0) -> Nothing + (sl, sc, el, ec) -> Just PosInfo{ startLine = sl + , startColumn = sc + , endLine = el + , endColumn = ec } + +handleNode :: (Maybe PosInfo -> NodeType -> [a] -> a) -> NodePtr -> a +handleNode f ptr = f posinfo (ptrToNodeType ptr) children + where children = handleNodes f $ c_cmark_node_first_child ptr + posinfo = getPosInfo ptr + handleNodes f ptr = + if ptr == nullPtr + then [] + else handleNode f ptr : handleNodes f (c_cmark_node_next ptr) + +toNode :: NodePtr -> Node +toNode = handleNode Node + +foreign import ccall "string.h strlen" + c_strlen :: CString -> Int + +foreign import ccall "cmark.h cmark_markdown_to_html" + c_cmark_markdown_to_html :: CString -> Int -> CInt -> CString + +foreign import ccall "cmark.h cmark_parse_document" + c_cmark_parse_document :: CString -> Int -> CInt -> NodePtr + +foreign import ccall "cmark.h cmark_node_get_type" + c_cmark_node_get_type :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_first_child" + c_cmark_node_first_child :: NodePtr -> NodePtr + +foreign import ccall "cmark.h cmark_node_next" + c_cmark_node_next :: NodePtr -> NodePtr + +foreign import ccall "cmark.h cmark_node_get_literal" + c_cmark_node_get_literal :: NodePtr -> CString + +foreign import ccall "cmark.h cmark_node_get_url" + c_cmark_node_get_url :: NodePtr -> CString + +foreign import ccall "cmark.h cmark_node_get_title" + c_cmark_node_get_title :: NodePtr -> CString + +foreign import ccall "cmark.h cmark_node_get_header_level" + c_cmark_node_get_header_level :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_get_list_type" + c_cmark_node_get_list_type :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_get_list_tight" + c_cmark_node_get_list_tight :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_get_list_delim" + c_cmark_node_get_list_delim :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_get_fence_info" + c_cmark_node_get_fence_info :: NodePtr -> CString + +foreign import ccall "cmark.h cmark_node_get_start_line" + c_cmark_node_get_start_line :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_get_start_column" + c_cmark_node_get_start_column :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_get_end_line" + c_cmark_node_get_end_line :: NodePtr -> Int + +foreign import ccall "cmark.h cmark_node_get_end_column" + c_cmark_node_get_end_column :: NodePtr -> Int + +-- | Convert CommonMark formatted text to Html, using cmark's +-- built-in renderer. +markdownToHtml :: [CMarkOption] -> Text -> Text +markdownToHtml opts s = io $ + TF.withCStringLen s $ \(ptr, len) -> + return (peekCString $ c_cmark_markdown_to_html ptr len (combineOptions opts)) + +-- | Convert CommonMark formatted text to a structured 'Node' tree, +-- which can be transformed or rendered using Haskell code. +parseDocument :: [CMarkOption] -> Text -> Node +parseDocument opts s = io $ + TF.withCStringLen s $ \(ptr, len) -> + return $ toNode $ c_cmark_parse_document ptr len (combineOptions opts) + +io :: IO a -> a +io = Unsafe.unsafePerformIO + +peekCString :: CString -> Text +peekCString str + | str == nullPtr = empty + | otherwise = io $ TF.peekCStringLen (str, c_strlen str) diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,103 @@ +Copyright (c) 2014, John MacFarlane + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---- + +houdini.h, houdini_href_e.c, houdini_html_e.c, houdini_html_u.c, +html_unescape.gperf, html_unescape.h + +derive from https://github.com/vmg/houdini (with some modifications) + +Copyright (C) 2012 Vicent Martí + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +----- + +buffer.h, buffer.c, chunk.h + +are derived from code (C) 2012 Github, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +----- + +utf8.c and utf8.c + +are derived from utf8proc +(), +(C) 2009 Public Software Group e. V., Berlin, Germany. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,79 @@ +cmark-hs +======== + +This package provides Haskell bindings for [libcmark], the reference +parser for [CommonMark]. It includes sources for [libcmark], and +does not require prior installation of the C library. + +cmark provides the following advantages over existing Markdown +libraries for Haskell: + + - **Speed:** Conversion speed is on par with the [sundown] library: + about 30 times faster than [pandoc], 24 times + faster than the Haskell [markdown] package, 8 times faster than + [cheapskate]. + + - **Memory footprint:** Memory footprint is on par with [sundown]. + On one sample, the library uses a fourth the memory that [markdown] + uses, and less than a tenth the memory that [pandoc] uses. + + - **Robustness:** cmark can handle whatever is thrown at it, + without the exponential blowups in parsing time one can sometimes + get with other libraries. For example, the input produced by + this command will tie [markdown] and [pandoc] in knots: + + python -c "print ((500 * '[') + 'hi' + (500 * ']') + '(url)')" + + cmark handles it easily, with no slowdown. + + - **Accuracy:** cmark passes the CommonMark spec's suite of over + 500 conformance tests. + + - **Standardization:** Since there is a spec and a comprehensive suite + of tests, we can have a high degree of confidence that any two + CommonMark implementations will behave the same. Thus, for + example, one could use this library for server-side rendering + and [commonmark.js] for client-side previewing. + + - **Ease of installation:** cmark has minimal dependencies. + +cmark does not provide Haskell versions of the whole [libcmark] +API, which is built around mutable `cmark_node` objects. Instead, it +provides two functions: + + - `markdownToHtml` uses [libcmark]'s parser and renderer for a + maximally efficient conversion of CommonMark to HTML (as a Text). + ("Smart punctuation" and a few other options can be enabled.) + + ``` haskell + Prelude CMark Data.Text> markdownToHtml [optSmart] (pack "dog's *breakfast*") + "

dog\8217s breakfast

\n" + ``` + + - `parseDocument` uses [libcmark]'s parser to produce a `Node` tree + that can be processed further using Haskell. One can transform + the tree using generics, convert it to another kind of + structure (such as a Pandoc object that can be rendered using + pandoc's renderers) or render it using a custom rendering + function. + + ``` haskell + Prelude CMark Data.Text> parseDocument [optSmart] (pack "dog's *breakfast*") + Node (Just (PosInfo {startLine = 1, startColumn = 1, endLine = 1, endColumn = 17})) DOCUMENT [Node (Just (PosInfo {startLine = 1, startColumn = 1, endLine = 1, endColumn = 17})) PARAGRAPH [Node Nothing (TEXT "dog") [],Node Nothing (TEXT "\8217") [],Node Nothing (TEXT "s ") [],Node Nothing EMPH [Node Nothing (TEXT "breakfast") []]]] + ``` + +**A note on security:** This library does not attempt to sanitize +HTML output. We recommend using [xss-sanitize] to filter the output. + +**A note on stability:** There is a good chance the API will change +significantly after this early release. + +[CommonMark]: http://commonmark.org +[libcmark]: http://github.com/jgm/cmark +[benchmarks]: https://github.com/jgm/cmark/blob/master/benchmarks.md +[cheapskate]: https://hackage.haskell.org/package/cheapskate +[pandoc]: https://hackage.haskell.org/package/pandoc +[sundown]: https://hackage.haskell.org/package/sundown +[markdown]: https://hackage.haskell.org/package/markdown +[commonmark.js]: http://github.com/jgm/commonmark.js +[xss-sanitize]: https://hackage.haskell.org/package/xss-sanitize diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/cmark.cabal b/cmark.cabal new file mode 100644 --- /dev/null +++ b/cmark.cabal @@ -0,0 +1,127 @@ +name: cmark +version: 0.1.0.0 +synopsis: Haskell bindings to libcmark, CommonMark parser and renderer +description: + This package provides Haskell bindings for + , the reference parser for + . It includes sources for + , and does not require prior + installation of the C library. + . + cmark provides the following advantages over existing Markdown libraries + for Haskell: + . + - __Speed:__ Conversion speed is on par with the + library: about + 30 times faster than + , 24 times faster + than the Haskell + package, 8 + times faster than + . + . + - __Memory footprint:__ Memory footprint is on par with + . On one + sample, the library uses a fourth the memory that + uses, and + less than a tenth the memory that + uses. + . + - __Robustness:__ cmark can handle whatever is thrown at it, without + the exponential blowups in parsing time one can sometimes get with + other libraries. + . + - __Accuracy:__ cmark passes the CommonMark spec\'s suite of over 500 + conformance tests. + . + - __Standardization:__ Since there is a spec and a comprehensive suite + of tests, we can have a high degree of confidence that any two + CommonMark implementations will behave the same. Thus, for example, + one could use this library for server-side rendering and + for client-side + previewing. + . + - __Ease of installation:__ cmark has minimal dependencies. + . + cmark does not provide Haskell versions of the whole + API, which is built around + mutable @cmark_node@ objects. Instead, it provides two functions: + . + - @markdownToHtml@ uses \'s + parser and renderer for a maximally efficient conversion of + CommonMark to HTML (as a Text). (\"Smart punctuation\" and a few + other options can be enabled.) + . + - @parseDocument@ uses \'s + parser to produce a @Node@ tree that can be processed further using + Haskell. One can transform the tree using generics, convert it to + another kind of structure (such as a Pandoc object that can be + rendered using pandoc\'s renderers) or render it using a custom + rendering function. + . + __A note on security:__ This library does not attempt to sanitize HTML + output. We recommend using + to + filter the output. + . + __A note on stability:__ There is a good chance the API will change + significantly after this early release. + +homepage: https://github.com/jgm/commonmark-hs +license: BSD2 +license-file: LICENSE +author: John MacFarlane +maintainer: jgm@berkeley.edu +copyright: (C) 2015 John MacFarlane +category: Text +build-type: Simple +extra-source-files: README.md + cmark/bench.h + cmark/chunk.h + cmark/cmark_export.h + cmark/debug.h + cmark/inlines.h + cmark/cmark.h + cmark/houdini.h + cmark/references.h + cmark/utf8.h + cmark/parser.h + cmark/cmark_version.h + cmark/html_unescape.h + cmark/iterator.h + cmark/node.h + cmark/buffer.h + cmark/cmark_ctype.h + cmark/config.h + cmark/scanners.h + cmark/case_fold_switch.inc +cabal-version: >=1.10 + +Source-repository head + type: git + location: git://github.com/jgm/cmark-hs.git + +library + exposed-modules: CMark + build-depends: base >=4.6 && < 4.8, mtl, syb, text >= 1.1 && < 1.3 + default-language: Haskell2010 + ghc-options: -Wall + Include-dirs: cmark + Includes: cmark.h + c-sources: cmark/houdini_html_u.c + cmark/man.c + cmark/references.c + cmark/utf8.c + cmark/blocks.c + cmark/cmark.c + cmark/html.c + cmark/iterator.c + cmark/node.c + cmark/buffer.c + cmark/cmark_ctype.c + cmark/houdini_href_e.c + cmark/scanners.c + cmark/xml.c + cmark/houdini_html_e.c + cmark/inlines.c + cmark/main.c diff --git a/cmark/bench.h b/cmark/bench.h new file mode 100644 --- /dev/null +++ b/cmark/bench.h @@ -0,0 +1,27 @@ +#ifndef CMARK_BENCH_H +#define CMARK_BENCH_H + +#include +#include + +#ifdef TIMER +float _cmark_start_time; +float _cmark_end_time; +float _cmark_save_time; + +#define start_timer() \ + _cmark_save_time = _cmark_start_time; \ + _cmark_start_time = (float)clock()/CLOCKS_PER_SEC + +#define end_timer(M) \ + _cmark_end_time = (float)clock()/CLOCKS_PER_SEC; \ + fprintf(stderr, "[TIME] (%s:%d) %4.f ns " M "\n", __FILE__, \ + __LINE__, (_cmark_end_time - _cmark_start_time) * 1000000); \ + _cmark_start_time = _cmark_save_time; + +#else +#define start_timer() +#define end_timer(M) +#endif + +#endif diff --git a/cmark/blocks.c b/cmark/blocks.c new file mode 100644 --- /dev/null +++ b/cmark/blocks.c @@ -0,0 +1,887 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "config.h" +#include "parser.h" +#include "cmark.h" +#include "node.h" +#include "references.h" +#include "utf8.h" +#include "scanners.h" +#include "inlines.h" +#include "houdini.h" +#include "buffer.h" +#include "debug.h" + +#define CODE_INDENT 4 +#define peek_at(i, n) (i)->data[n] + +static void +S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, + bool eof); + +static void +S_process_line(cmark_parser *parser, const unsigned char *buffer, + size_t bytes); + +static cmark_node* make_block(cmark_node_type tag, int start_line, int start_column) +{ + cmark_node* e; + + e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = tag; + e->open = true; + e->start_line = start_line; + e->start_column = start_column; + e->end_line = start_line; + cmark_strbuf_init(&e->string_content, 32); + } + + return e; +} + +// Create a root document node. +static cmark_node* make_document() +{ + cmark_node *e = make_block(NODE_DOCUMENT, 1, 1); + return e; +} + +cmark_parser *cmark_parser_new(int options) +{ + cmark_parser *parser = (cmark_parser*)malloc(sizeof(cmark_parser)); + cmark_node *document = make_document(); + cmark_strbuf *line = (cmark_strbuf*)malloc(sizeof(cmark_strbuf)); + cmark_strbuf *buf = (cmark_strbuf*)malloc(sizeof(cmark_strbuf)); + cmark_strbuf_init(line, 256); + cmark_strbuf_init(buf, 0); + + parser->refmap = cmark_reference_map_new(); + parser->root = document; + parser->current = document; + parser->line_number = 0; + parser->curline = line; + parser->last_line_length = 0; + parser->linebuf = buf; + parser->options = options; + + return parser; +} + +void cmark_parser_free(cmark_parser *parser) +{ + cmark_strbuf_free(parser->curline); + free(parser->curline); + cmark_strbuf_free(parser->linebuf); + free(parser->linebuf); + cmark_reference_map_free(parser->refmap); + free(parser); +} + +static cmark_node* +finalize(cmark_parser *parser, cmark_node* b); + +// Returns true if line has only space characters, else false. +static bool is_blank(cmark_strbuf *s, int offset) +{ + while (offset < s->size) { + switch (s->ptr[offset]) { + case '\n': + return true; + case ' ': + offset++; + break; + default: + return false; + } + } + + return true; +} + +static inline bool can_contain(cmark_node_type parent_type, cmark_node_type child_type) +{ + return ( parent_type == NODE_DOCUMENT || + parent_type == NODE_BLOCK_QUOTE || + parent_type == NODE_ITEM || + (parent_type == NODE_LIST && child_type == NODE_ITEM) ); +} + +static inline bool accepts_lines(cmark_node_type block_type) +{ + return (block_type == NODE_PARAGRAPH || + block_type == NODE_HEADER || + block_type == NODE_CODE_BLOCK); +} + +static void add_line(cmark_node* node, cmark_chunk *ch, int offset) +{ + assert(node->open); + cmark_strbuf_put(&node->string_content, ch->data + offset, ch->len - offset); +} + +static void remove_trailing_blank_lines(cmark_strbuf *ln) +{ + int i; + + for (i = ln->size - 1; i >= 0; --i) { + unsigned char c = ln->ptr[i]; + + if (c != ' ' && c != '\t' && c != '\r' && c != '\n') + break; + } + + if (i < 0) { + cmark_strbuf_clear(ln); + return; + } + + i = cmark_strbuf_strchr(ln, '\n', i); + if (i >= 0) + cmark_strbuf_truncate(ln, i); +} + +// Check to see if a node ends with a blank line, descending +// if needed into lists and sublists. +static bool ends_with_blank_line(cmark_node* node) +{ + cmark_node *cur = node; + while (cur != NULL) { + if (cur->last_line_blank) { + return true; + } + if (cur->type == NODE_LIST || cur->type == NODE_ITEM) { + cur = cur->last_child; + } else { + cur = NULL; + } + } + return false; +} + +// Break out of all containing lists +static int break_out_of_lists(cmark_parser *parser, cmark_node ** bptr) +{ + cmark_node *container = *bptr; + cmark_node *b = parser->root; + // find first containing NODE_LIST: + while (b && b->type != NODE_LIST) { + b = b->last_child; + } + if (b) { + while (container && container != b) { + container = finalize(parser, container); + } + finalize(parser, b); + *bptr = b->parent; + } + return 0; +} + + +static cmark_node* +finalize(cmark_parser *parser, cmark_node* b) +{ + int firstlinelen; + int pos; + cmark_node* item; + cmark_node* subitem; + cmark_node* parent; + + parent = b->parent; + + assert(b->open); // shouldn't call finalize on closed blocks + b->open = false; + + if (parser->curline->size == 0) { + // end of input - line number has not been incremented + b->end_line = parser->line_number; + b->end_column = parser->last_line_length; + } else if (b->type == NODE_DOCUMENT || + (b->type == NODE_CODE_BLOCK && b->as.code.fenced) || + (b->type == NODE_HEADER && b->as.header.setext)) { + b->end_line = parser->line_number; + b->end_column = parser->curline->size - + (parser->curline->ptr[parser->curline->size - 1] == '\n' ? + 1 : 0); + } else { + b->end_line = parser->line_number - 1; + b->end_column = parser->last_line_length; + } + + switch (b->type) { + case NODE_PARAGRAPH: + while (cmark_strbuf_at(&b->string_content, 0) == '[' && + (pos = cmark_parse_reference_inline(&b->string_content, parser->refmap))) { + + cmark_strbuf_drop(&b->string_content, pos); + } + if (is_blank(&b->string_content, 0)) { + // remove blank node (former reference def) + cmark_node_free(b); + } + break; + + case NODE_CODE_BLOCK: + if (!b->as.code.fenced) { // indented code + remove_trailing_blank_lines(&b->string_content); + cmark_strbuf_putc(&b->string_content, '\n'); + } else { + + // first line of contents becomes info + firstlinelen = cmark_strbuf_strchr(&b->string_content, '\n', 0); + + cmark_strbuf tmp = GH_BUF_INIT; + houdini_unescape_html_f( + &tmp, + b->string_content.ptr, + firstlinelen + ); + cmark_strbuf_trim(&tmp); + cmark_strbuf_unescape(&tmp); + b->as.code.info = cmark_chunk_buf_detach(&tmp); + + cmark_strbuf_drop(&b->string_content, firstlinelen + 1); + } + b->as.code.literal = cmark_chunk_buf_detach(&b->string_content); + break; + + case NODE_HTML: + b->as.literal = cmark_chunk_buf_detach(&b->string_content); + break; + + case NODE_LIST: // determine tight/loose status + b->as.list.tight = true; // tight by default + item = b->first_child; + + while (item) { + // check for non-final non-empty list item ending with blank line: + if (item->last_line_blank && item->next) { + b->as.list.tight = false; + break; + } + // recurse into children of list item, to see if there are + // spaces between them: + subitem = item->first_child; + while (subitem) { + if (ends_with_blank_line(subitem) && + (item->next || subitem->next)) { + b->as.list.tight = false; + break; + } + subitem = subitem->next; + } + if (!(b->as.list.tight)) { + break; + } + item = item->next; + } + + break; + + default: + break; + } + return parent; +} + +// Add a node as child of another. Return pointer to child. +static cmark_node* add_child(cmark_parser *parser, cmark_node* parent, + cmark_node_type block_type, int start_column) +{ + assert(parent); + + // if 'parent' isn't the kind of node that can accept this child, + // then back up til we hit a node that can. + while (!can_contain(parent->type, block_type)) { + parent = finalize(parser, parent); + } + + cmark_node* child = make_block(block_type, parser->line_number, start_column); + child->parent = parent; + + if (parent->last_child) { + parent->last_child->next = child; + child->prev = parent->last_child; + } else { + parent->first_child = child; + child->prev = NULL; + } + parent->last_child = child; + return child; +} + + +// Walk through node and all children, recursively, parsing +// string content into inline content where appropriate. +static void process_inlines(cmark_node* root, cmark_reference_map *refmap, int options) +{ + cmark_iter *iter = cmark_iter_new(root); + cmark_node *cur; + cmark_event_type ev_type; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (ev_type == CMARK_EVENT_ENTER) { + if (cur->type == NODE_PARAGRAPH || + cur->type == NODE_HEADER) { + cmark_parse_inlines(cur, refmap, options); + } + } + } + + cmark_iter_free(iter); +} + +// Attempts to parse a list item marker (bullet or enumerated). +// On success, returns length of the marker, and populates +// data with the details. On failure, returns 0. +static int parse_list_marker(cmark_chunk *input, int pos, cmark_list **dataptr) +{ + unsigned char c; + int startpos; + cmark_list *data; + + startpos = pos; + c = peek_at(input, pos); + + if ((c == '*' || c == '-' || c == '+') && !scan_hrule(input, pos)) { + pos++; + if (!cmark_isspace(peek_at(input, pos))) { + return 0; + } + data = (cmark_list *)calloc(1, sizeof(*data)); + if(data == NULL) { + return 0; + } else { + data->marker_offset = 0; // will be adjusted later + data->list_type = CMARK_BULLET_LIST; + data->bullet_char = c; + data->start = 1; + data->delimiter = CMARK_PERIOD_DELIM; + data->tight = false; + } + } else if (cmark_isdigit(c)) { + int start = 0; + + do { + start = (10 * start) + (peek_at(input, pos) - '0'); + pos++; + } while (cmark_isdigit(peek_at(input, pos))); + + c = peek_at(input, pos); + if (c == '.' || c == ')') { + pos++; + if (!cmark_isspace(peek_at(input, pos))) { + return 0; + } + data = (cmark_list *)calloc(1, sizeof(*data)); + if(data == NULL) { + return 0; + } else { + data->marker_offset = 0; // will be adjusted later + data->list_type = CMARK_ORDERED_LIST; + data->bullet_char = 0; + data->start = start; + data->delimiter = (c == '.' ? CMARK_PERIOD_DELIM : CMARK_PAREN_DELIM); + data->tight = false; + } + } else { + return 0; + } + + } else { + return 0; + } + + *dataptr = data; + return (pos - startpos); +} + +// Return 1 if list item belongs in list, else 0. +static int lists_match(cmark_list *list_data, cmark_list *item_data) +{ + return (list_data->list_type == item_data->list_type && + list_data->delimiter == item_data->delimiter && + // list_data->marker_offset == item_data.marker_offset && + list_data->bullet_char == item_data->bullet_char); +} + +static cmark_node *finalize_document(cmark_parser *parser) +{ + while (parser->current != parser->root) { + parser->current = finalize(parser, parser->current); + } + + finalize(parser, parser->root); + process_inlines(parser->root, parser->refmap, parser->options); + + return parser->root; +} + +cmark_node *cmark_parse_file(FILE *f, int options) +{ + unsigned char buffer[4096]; + cmark_parser *parser = cmark_parser_new(options); + size_t bytes; + cmark_node *document; + + while ((bytes = fread(buffer, 1, sizeof(buffer), f)) > 0) { + bool eof = bytes < sizeof(buffer); + S_parser_feed(parser, buffer, bytes, eof); + if (eof) { + break; + } + } + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options) +{ + cmark_parser *parser = cmark_parser_new(options); + cmark_node *document; + + S_parser_feed(parser, (const unsigned char *)buffer, len, true); + + document = cmark_parser_finish(parser); + cmark_parser_free(parser); + return document; +} + +void +cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len) +{ + S_parser_feed(parser, (const unsigned char *)buffer, len, false); +} + +static void +S_parser_feed(cmark_parser *parser, const unsigned char *buffer, size_t len, + bool eof) +{ + const unsigned char *end = buffer + len; + + while (buffer < end) { + const unsigned char *eol + = (const unsigned char *)memchr(buffer, '\n', + end - buffer); + size_t line_len; + + if (eol) { + line_len = eol + 1 - buffer; + } else if (eof) { + line_len = end - buffer; + } else { + cmark_strbuf_put(parser->linebuf, buffer, end - buffer); + break; + } + + if (parser->linebuf->size > 0) { + cmark_strbuf_put(parser->linebuf, buffer, line_len); + S_process_line(parser, parser->linebuf->ptr, + parser->linebuf->size); + cmark_strbuf_clear(parser->linebuf); + } else { + S_process_line(parser, buffer, line_len); + } + + buffer += line_len; + } +} + +static void chop_trailing_hashtags(cmark_chunk *ch) +{ + int n, orig_n; + + cmark_chunk_rtrim(ch); + orig_n = n = ch->len - 1; + + // if string ends in space followed by #s, remove these: + while (n >= 0 && peek_at(ch, n) == '#') + n--; + + // Check for a be a space before the final #s: + if (n != orig_n && n >= 0 && peek_at(ch, n) == ' ') { + ch->len = n; + cmark_chunk_rtrim(ch); + } +} + +static void +S_process_line(cmark_parser *parser, const unsigned char *buffer, size_t bytes) +{ + cmark_node* last_matched_container; + int offset = 0; + int matched = 0; + int lev = 0; + int i; + cmark_list *data = NULL; + bool all_matched = true; + cmark_node* container; + bool blank = false; + int first_nonspace; + int indent; + cmark_chunk input; + bool maybe_lazy; + + utf8proc_detab(parser->curline, buffer, bytes); + + // Add a newline to the end if not present: + // TODO this breaks abstraction: + if (parser->curline->ptr[parser->curline->size - 1] != '\n') { + cmark_strbuf_putc(parser->curline, '\n'); + } + input.data = parser->curline->ptr; + input.len = parser->curline->size; + + // container starts at the document root. + container = parser->root; + + parser->line_number++; + + // for each containing node, try to parse the associated line start. + // bail out on failure: container will point to the last matching node. + + while (container->last_child && container->last_child->open) { + container = container->last_child; + + first_nonspace = offset; + while (peek_at(&input, first_nonspace) == ' ') { + first_nonspace++; + } + + indent = first_nonspace - offset; + blank = peek_at(&input, first_nonspace) == '\n'; + + if (container->type == NODE_BLOCK_QUOTE) { + matched = indent <= 3 && peek_at(&input, first_nonspace) == '>'; + if (matched) { + offset = first_nonspace + 1; + if (peek_at(&input, offset) == ' ') + offset++; + } else { + all_matched = false; + } + + } else if (container->type == NODE_ITEM) { + + if (indent >= container->as.list.marker_offset + + container->as.list.padding) { + offset += container->as.list.marker_offset + + container->as.list.padding; + } else if (blank) { + offset = first_nonspace; + } else { + all_matched = false; + } + + } else if (container->type == NODE_CODE_BLOCK) { + + if (!container->as.code.fenced) { // indented + if (indent >= CODE_INDENT) { + offset += CODE_INDENT; + } else if (blank) { + offset = first_nonspace; + } else { + all_matched = false; + } + } else { // fenced + matched = 0; + if (indent <= 3 && + (peek_at(&input, first_nonspace) == + container->as.code.fence_char)) { + matched = scan_close_code_fence(&input, + first_nonspace); + } + if (matched >= container->as.code.fence_length) { + // closing fence - and since we're at + // the end of a line, we can return: + all_matched = false; + offset += matched; + parser->current = finalize(parser, container); + goto finished; + } else { + // skip opt. spaces of fence offset + i = container->as.code.fence_offset; + while (i > 0 && + peek_at(&input, offset) == ' ') { + offset++; + i--; + } + } + } + } else if (container->type == NODE_HEADER) { + + // a header can never contain more than one line + all_matched = false; + + } else if (container->type == NODE_HTML) { + + if (blank) { + all_matched = false; + } + + } else if (container->type == NODE_PARAGRAPH) { + + if (blank) { + all_matched = false; + } + + } + + if (!all_matched) { + container = container->parent; // back up to last matching node + break; + } + } + + last_matched_container = container; + + // check to see if we've hit 2nd blank line, break out of list: + if (blank && container->last_line_blank) { + break_out_of_lists(parser, &container); + } + + maybe_lazy = parser->current->type == NODE_PARAGRAPH; + // try new container starts: + while (container->type != NODE_CODE_BLOCK && + container->type != NODE_HTML) { + + first_nonspace = offset; + while (peek_at(&input, first_nonspace) == ' ') + first_nonspace++; + + indent = first_nonspace - offset; + blank = peek_at(&input, first_nonspace) == '\n'; + + if (indent >= CODE_INDENT) { + if (!maybe_lazy && !blank) { + offset += CODE_INDENT; + container = add_child(parser, container, NODE_CODE_BLOCK, offset + 1); + container->as.code.fenced = false; + container->as.code.fence_char = 0; + container->as.code.fence_length = 0; + container->as.code.fence_offset = 0; + container->as.code.info = cmark_chunk_literal(""); + } else { // indent > 4 in lazy line + break; + } + + } else if (peek_at(&input, first_nonspace) == '>') { + + offset = first_nonspace + 1; + // optional following character + if (peek_at(&input, offset) == ' ') + offset++; + container = add_child(parser, container, NODE_BLOCK_QUOTE, offset + 1); + + } else if ((matched = scan_atx_header_start(&input, first_nonspace))) { + + offset = first_nonspace + matched; + container = add_child(parser, container, NODE_HEADER, offset + 1); + + int hashpos = cmark_chunk_strchr(&input, '#', first_nonspace); + int level = 0; + + while (peek_at(&input, hashpos) == '#') { + level++; + hashpos++; + } + container->as.header.level = level; + container->as.header.setext = false; + + } else if ((matched = scan_open_code_fence(&input, first_nonspace))) { + + container = add_child(parser, container, NODE_CODE_BLOCK, first_nonspace + 1); + container->as.code.fenced = true; + container->as.code.fence_char = peek_at(&input, first_nonspace); + container->as.code.fence_length = matched; + container->as.code.fence_offset = first_nonspace - offset; + container->as.code.info = cmark_chunk_literal(""); + offset = first_nonspace + matched; + + } else if ((matched = scan_html_block_tag(&input, first_nonspace))) { + + container = add_child(parser, container, NODE_HTML, first_nonspace + 1); + // note, we don't adjust offset because the tag is part of the text + + } else if (container->type == NODE_PARAGRAPH && + (lev = scan_setext_header_line(&input, first_nonspace)) && + // check that there is only one line in the paragraph: + cmark_strbuf_strrchr(&container->string_content, '\n', + cmark_strbuf_len(&container->string_content) - 2) < 0) { + + container->type = NODE_HEADER; + container->as.header.level = lev; + container->as.header.setext = true; + offset = input.len - 1; + + } else if (!(container->type == NODE_PARAGRAPH && !all_matched) && + (matched = scan_hrule(&input, first_nonspace))) { + + // it's only now that we know the line is not part of a setext header: + container = add_child(parser, container, NODE_HRULE, first_nonspace + 1); + container = finalize(parser, container); + offset = input.len - 1; + + } else if ((matched = parse_list_marker(&input, first_nonspace, &data))) { + + // compute padding: + offset = first_nonspace + matched; + i = 0; + while (i <= 5 && peek_at(&input, offset + i) == ' ') { + i++; + } + // i = number of spaces after marker, up to 5 + if (i >= 5 || i < 1 || peek_at(&input, offset) == '\n') { + data->padding = matched + 1; + if (i > 0) { + offset += 1; + } + } else { + data->padding = matched + i; + offset += i; + } + + // check container; if it's a list, see if this list item + // can continue the list; otherwise, create a list container. + + data->marker_offset = indent; + + if (container->type != NODE_LIST || + !lists_match(&container->as.list, data)) { + container = add_child(parser, container, NODE_LIST, + first_nonspace + 1); + + memcpy(&container->as.list, data, sizeof(*data)); + } + + // add the list item + container = add_child(parser, container, NODE_ITEM, + first_nonspace + 1); + /* TODO: static */ + memcpy(&container->as.list, data, sizeof(*data)); + free(data); + } else { + break; + } + + if (accepts_lines(container->type)) { + // if it's a line container, it can't contain other containers + break; + } + maybe_lazy = false; + } + + // what remains at offset is a text line. add the text to the + // appropriate container. + + first_nonspace = offset; + while (peek_at(&input, first_nonspace) == ' ') + first_nonspace++; + + indent = first_nonspace - offset; + blank = peek_at(&input, first_nonspace) == '\n'; + + if (blank && container->last_child) { + container->last_child->last_line_blank = true; + } + + // block quote lines are never blank as they start with > + // and we don't count blanks in fenced code for purposes of tight/loose + // lists or breaking out of lists. we also don't set last_line_blank + // on an empty list item. + container->last_line_blank = (blank && + container->type != NODE_BLOCK_QUOTE && + container->type != NODE_HEADER && + !(container->type == NODE_CODE_BLOCK && + container->as.code.fenced) && + !(container->type == NODE_ITEM && + container->first_child == NULL && + container->start_line == parser->line_number)); + + cmark_node *cont = container; + while (cont->parent) { + cont->parent->last_line_blank = false; + cont = cont->parent; + } + + if (parser->current != last_matched_container && + container == last_matched_container && + !blank && + parser->current->type == NODE_PARAGRAPH && + cmark_strbuf_len(&parser->current->string_content) > 0) { + + add_line(parser->current, &input, offset); + + } else { // not a lazy continuation + + // finalize any blocks that were not matched and set cur to container: + while (parser->current != last_matched_container) { + parser->current = finalize(parser, parser->current); + assert(parser->current != NULL); + } + + if (container->type == NODE_CODE_BLOCK || + container->type == NODE_HTML) { + + add_line(container, &input, offset); + + } else if (blank) { + + // ??? do nothing + + } else if (accepts_lines(container->type)) { + + if (container->type == NODE_HEADER && + container->as.header.setext == false) { + chop_trailing_hashtags(&input); + } + add_line(container, &input, first_nonspace); + + } else { + // create paragraph container for line + container = add_child(parser, container, NODE_PARAGRAPH, first_nonspace + 1); + add_line(container, &input, first_nonspace); + + } + + parser->current = container; + } +finished: + parser->last_line_length = parser->curline->size - + (parser->curline->ptr[parser->curline->size - 1] == '\n' ? + 1 : 0); + ; + cmark_strbuf_clear(parser->curline); + +} + +cmark_node *cmark_parser_finish(cmark_parser *parser) +{ + if (parser->linebuf->size) { + S_process_line(parser, parser->linebuf->ptr, + parser->linebuf->size); + cmark_strbuf_clear(parser->linebuf); + } + + finalize_document(parser); + + if (parser->options & CMARK_OPT_NORMALIZE) { + cmark_consolidate_text_nodes(parser->root); + } + + cmark_strbuf_free(parser->curline); + +#if CMARK_DEBUG_NODES + if (cmark_node_check(parser->root, stderr)) { + abort(); + } +#endif + return parser->root; +} diff --git a/cmark/buffer.c b/cmark/buffer.c new file mode 100644 --- /dev/null +++ b/cmark/buffer.c @@ -0,0 +1,381 @@ +#include +#include +#include +#include +#include +#include + +#include "config.h" +#include "cmark_ctype.h" +#include "buffer.h" + +/* Used as default value for cmark_strbuf->ptr so that people can always + * assume ptr is non-NULL and zero terminated even for new cmark_strbufs. + */ +unsigned char cmark_strbuf__initbuf[1]; +unsigned char cmark_strbuf__oom[1]; + +#define ENSURE_SIZE(b, d) \ + if ((d) > buf->asize && cmark_strbuf_grow(b, (d)) < 0) \ + return -1; + +#ifndef MIN +#define MIN(x,y) ((xasize = 0; + buf->size = 0; + buf->ptr = cmark_strbuf__initbuf; + + if (initial_size) + cmark_strbuf_grow(buf, initial_size); +} + +int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom) +{ + unsigned char *new_ptr; + int new_size; + + if (buf->ptr == cmark_strbuf__oom) + return -1; + + if (target_size <= buf->asize) + return 0; + + if (buf->asize == 0) { + new_size = target_size; + new_ptr = NULL; + } else { + new_size = buf->asize; + new_ptr = buf->ptr; + } + + /* grow the buffer size by 1.5, until it's big enough + * to fit our target size */ + while (new_size < target_size) + new_size = (new_size << 1) - (new_size >> 1); + + /* round allocation up to multiple of 8 */ + new_size = (new_size + 7) & ~7; + + new_ptr = (unsigned char *)realloc(new_ptr, new_size); + + if (!new_ptr) { + if (mark_oom) + buf->ptr = cmark_strbuf__oom; + return -1; + } + + buf->asize = new_size; + buf->ptr = new_ptr; + + /* truncate the existing buffer size if necessary */ + if (buf->size >= buf->asize) + buf->size = buf->asize - 1; + buf->ptr[buf->size] = '\0'; + + return 0; +} + +int cmark_strbuf_grow(cmark_strbuf *buf, int target_size) +{ + return cmark_strbuf_try_grow(buf, target_size, true); +} + +bool cmark_strbuf_oom(const cmark_strbuf *buf) +{ + return (buf->ptr == cmark_strbuf__oom); +} + +size_t cmark_strbuf_len(const cmark_strbuf *buf) +{ + return buf->size; +} + +void cmark_strbuf_free(cmark_strbuf *buf) +{ + if (!buf) return; + + if (buf->ptr != cmark_strbuf__initbuf && buf->ptr != cmark_strbuf__oom) + free(buf->ptr); + + cmark_strbuf_init(buf, 0); +} + +void cmark_strbuf_clear(cmark_strbuf *buf) +{ + buf->size = 0; + + if (buf->asize > 0) + buf->ptr[0] = '\0'; +} + +int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len) +{ + if (len <= 0 || data == NULL) { + cmark_strbuf_clear(buf); + } else { + if (data != buf->ptr) { + ENSURE_SIZE(buf, len + 1); + memmove(buf->ptr, data, len); + } + buf->size = len; + buf->ptr[buf->size] = '\0'; + } + return 0; +} + +int cmark_strbuf_sets(cmark_strbuf *buf, const char *string) +{ + return cmark_strbuf_set(buf, + (const unsigned char *)string, + string ? strlen(string) : 0); +} + +int cmark_strbuf_putc(cmark_strbuf *buf, int c) +{ + ENSURE_SIZE(buf, buf->size + 2); + buf->ptr[buf->size++] = c; + buf->ptr[buf->size] = '\0'; + return 0; +} + +int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len) +{ + if (len <= 0) + return 0; + + ENSURE_SIZE(buf, buf->size + len + 1); + memmove(buf->ptr + buf->size, data, len); + buf->size += len; + buf->ptr[buf->size] = '\0'; + return 0; +} + +int cmark_strbuf_puts(cmark_strbuf *buf, const char *string) +{ + return cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string)); +} + +int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap) +{ + const int expected_size = buf->size + (strlen(format) * 2); + int len; + + ENSURE_SIZE(buf, expected_size); + + while (1) { + va_list args; + va_copy(args, ap); + + len = vsnprintf( + (char *)buf->ptr + buf->size, + buf->asize - buf->size, + format, args + ); + + va_end(args); + + if (len < 0) { + free(buf->ptr); + buf->ptr = cmark_strbuf__oom; + return -1; + } + + if (len + 1 <= buf->asize - buf->size) { + buf->size += len; + break; + } + + ENSURE_SIZE(buf, buf->size + len + 1); + } + + return 0; +} + +int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) +{ + int r; + va_list ap; + + va_start(ap, format); + r = cmark_strbuf_vprintf(buf, format, ap); + va_end(ap); + + return r; +} + +void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf) +{ + int copylen; + + assert(data && datasize && buf); + + data[0] = '\0'; + + if (buf->size == 0 || buf->asize <= 0) + return; + + copylen = buf->size; + if (copylen > datasize - 1) + copylen = datasize - 1; + memmove(data, buf->ptr, copylen); + data[copylen] = '\0'; +} + +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) +{ + cmark_strbuf t = *buf_a; + *buf_a = *buf_b; + *buf_b = t; +} + +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) +{ + unsigned char *data = buf->ptr; + + if (buf->asize == 0 || buf->ptr == cmark_strbuf__oom) { + /* return an empty string */ + return (unsigned char *)calloc(1, 1); + } + + cmark_strbuf_init(buf, 0); + return data; +} + +void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize) +{ + cmark_strbuf_free(buf); + + if (ptr) { + buf->ptr = ptr; + buf->size = strlen((char *)ptr); + if (asize) + buf->asize = (asize < buf->size) ? buf->size + 1 : asize; + else /* pass 0 to fall back on strlen + 1 */ + buf->asize = buf->size + 1; + } else { + cmark_strbuf_grow(buf, asize); + } +} + +int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) +{ + int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size)); + return (result != 0) ? result : + (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0; +} + +int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos) +{ + const unsigned char *p = (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos); + if (!p) + return -1; + + return (int)(p - (const unsigned char *)buf->ptr); +} + +int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos) +{ + int i; + + for (i = pos; i >= 0; i--) { + if (buf->ptr[i] == (unsigned char) c) + return i; + } + + return -1; +} + +void cmark_strbuf_truncate(cmark_strbuf *buf, int len) +{ + if (len < buf->size) { + buf->size = len; + buf->ptr[buf->size] = '\0'; + } +} + +void cmark_strbuf_drop(cmark_strbuf *buf, int n) +{ + if (n > 0) { + buf->size = buf->size - n; + if (buf->size) + memmove(buf->ptr, buf->ptr + n, buf->size); + + buf->ptr[buf->size] = '\0'; + } +} + +void cmark_strbuf_rtrim(cmark_strbuf *buf) +{ + if (!buf->size) + return; + + while (buf->size > 0) { + if (!cmark_isspace(buf->ptr[buf->size - 1])) + break; + + buf->size--; + } + + buf->ptr[buf->size] = '\0'; +} + +void cmark_strbuf_trim(cmark_strbuf *buf) +{ + int i = 0; + + if (!buf->size) + return; + + while (i < buf->size && cmark_isspace(buf->ptr[i])) + i++; + + cmark_strbuf_drop(buf, i); + + cmark_strbuf_rtrim(buf); +} + +// Destructively modify string, collapsing consecutive +// space and newline characters into a single space. +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) +{ + bool last_char_was_space = false; + int r, w; + + for (r = 0, w = 0; r < s->size; ++r) { + switch (s->ptr[r]) { + case ' ': + case '\n': + if (last_char_was_space) + break; + + s->ptr[w++] = ' '; + last_char_was_space = true; + break; + + default: + s->ptr[w++] = s->ptr[r]; + last_char_was_space = false; + } + } + + cmark_strbuf_truncate(s, w); +} + +// Destructively unescape a string: remove backslashes before punctuation chars. +extern void cmark_strbuf_unescape(cmark_strbuf *buf) +{ + int r, w; + + for (r = 0, w = 0; r < buf->size; ++r) { + if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1])) + continue; + + buf->ptr[w++] = buf->ptr[r]; + } + + cmark_strbuf_truncate(buf, w); +} diff --git a/cmark/buffer.h b/cmark/buffer.h new file mode 100644 --- /dev/null +++ b/cmark/buffer.h @@ -0,0 +1,113 @@ +#ifndef CMARK_BUFFER_H +#define CMARK_BUFFER_H + +#include +#include +#include "config.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + unsigned char *ptr; + int asize, size; +} cmark_strbuf; + +extern unsigned char cmark_strbuf__initbuf[]; + +extern unsigned char cmark_strbuf__oom[]; + +#define GH_BUF_INIT { cmark_strbuf__initbuf, 0, 0 } + +/** + * Initialize a cmark_strbuf structure. + * + * For the cases where GH_BUF_INIT cannot be used to do static + * initialization. + */ +void cmark_strbuf_init(cmark_strbuf *buf, int initial_size); + +/** + * Attempt to grow the buffer to hold at least `target_size` bytes. + * + * If the allocation fails, this will return an error. If mark_oom is true, + * this will mark the buffer as invalid for future operations; if false, + * existing buffer content will be preserved, but calling code must handle + * that buffer was not expanded. + */ +int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom); + +/** + * Grow the buffer to hold at least `target_size` bytes. + * + * If the allocation fails, this will return an error and the buffer will be + * marked as invalid for future operations, invaliding contents. + * + * @return 0 on success or -1 on failure + */ +int cmark_strbuf_grow(cmark_strbuf *buf, int target_size); + +void cmark_strbuf_free(cmark_strbuf *buf); +void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b); + +/** + * Test if there have been any reallocation failures with this cmark_strbuf. + * + * Any function that writes to a cmark_strbuf can fail due to memory allocation + * issues. If one fails, the cmark_strbuf will be marked with an OOM error and + * further calls to modify the buffer will fail. Check cmark_strbuf_oom() at the + * end of your sequence and it will be true if you ran out of memory at any + * point with that buffer. + * + * @return false if no error, true if allocation error + */ +bool cmark_strbuf_oom(const cmark_strbuf *buf); + +size_t cmark_strbuf_len(const cmark_strbuf *buf); + +int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b); + +void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize); +unsigned char *cmark_strbuf_detach(cmark_strbuf *buf); +void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf); + +static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf) +{ + return (char *)buf->ptr; +} + +#define cmark_strbuf_at(buf, n) ((buf)->ptr[n]) + +/* + * Functions below that return int value error codes will return 0 on + * success or -1 on failure (which generally means an allocation failed). + * Using a cmark_strbuf where the allocation has failed with result in -1 from + * all further calls using that buffer. As a result, you can ignore the + * return code of these functions and call them in a series then just call + * cmark_strbuf_oom at the end. + */ +int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len); +int cmark_strbuf_sets(cmark_strbuf *buf, const char *string); +int cmark_strbuf_putc(cmark_strbuf *buf, int c); +int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len); +int cmark_strbuf_puts(cmark_strbuf *buf, const char *string); +int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...) +CMARK_ATTRIBUTE((format (printf, 2, 3))); +int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap); +void cmark_strbuf_clear(cmark_strbuf *buf); + +int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos); +int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos); +void cmark_strbuf_drop(cmark_strbuf *buf, int n); +void cmark_strbuf_truncate(cmark_strbuf *buf, int len); +void cmark_strbuf_rtrim(cmark_strbuf *buf); +void cmark_strbuf_trim(cmark_strbuf *buf); +void cmark_strbuf_normalize_whitespace(cmark_strbuf *s); +void cmark_strbuf_unescape(cmark_strbuf *s); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/case_fold_switch.inc b/cmark/case_fold_switch.inc new file mode 100644 --- /dev/null +++ b/cmark/case_fold_switch.inc @@ -0,0 +1,2637 @@ + switch (c) { + case 0x0041: + bufpush(0x0061); + break; + case 0x0042: + bufpush(0x0062); + break; + case 0x0043: + bufpush(0x0063); + break; + case 0x0044: + bufpush(0x0064); + break; + case 0x0045: + bufpush(0x0065); + break; + case 0x0046: + bufpush(0x0066); + break; + case 0x0047: + bufpush(0x0067); + break; + case 0x0048: + bufpush(0x0068); + break; + case 0x0049: + bufpush(0x0069); + break; + case 0x004A: + bufpush(0x006A); + break; + case 0x004B: + bufpush(0x006B); + break; + case 0x004C: + bufpush(0x006C); + break; + case 0x004D: + bufpush(0x006D); + break; + case 0x004E: + bufpush(0x006E); + break; + case 0x004F: + bufpush(0x006F); + break; + case 0x0050: + bufpush(0x0070); + break; + case 0x0051: + bufpush(0x0071); + break; + case 0x0052: + bufpush(0x0072); + break; + case 0x0053: + bufpush(0x0073); + break; + case 0x0054: + bufpush(0x0074); + break; + case 0x0055: + bufpush(0x0075); + break; + case 0x0056: + bufpush(0x0076); + break; + case 0x0057: + bufpush(0x0077); + break; + case 0x0058: + bufpush(0x0078); + break; + case 0x0059: + bufpush(0x0079); + break; + case 0x005A: + bufpush(0x007A); + break; + case 0x00B5: + bufpush(0x03BC); + break; + case 0x00C0: + bufpush(0x00E0); + break; + case 0x00C1: + bufpush(0x00E1); + break; + case 0x00C2: + bufpush(0x00E2); + break; + case 0x00C3: + bufpush(0x00E3); + break; + case 0x00C4: + bufpush(0x00E4); + break; + case 0x00C5: + bufpush(0x00E5); + break; + case 0x00C6: + bufpush(0x00E6); + break; + case 0x00C7: + bufpush(0x00E7); + break; + case 0x00C8: + bufpush(0x00E8); + break; + case 0x00C9: + bufpush(0x00E9); + break; + case 0x00CA: + bufpush(0x00EA); + break; + case 0x00CB: + bufpush(0x00EB); + break; + case 0x00CC: + bufpush(0x00EC); + break; + case 0x00CD: + bufpush(0x00ED); + break; + case 0x00CE: + bufpush(0x00EE); + break; + case 0x00CF: + bufpush(0x00EF); + break; + case 0x00D0: + bufpush(0x00F0); + break; + case 0x00D1: + bufpush(0x00F1); + break; + case 0x00D2: + bufpush(0x00F2); + break; + case 0x00D3: + bufpush(0x00F3); + break; + case 0x00D4: + bufpush(0x00F4); + break; + case 0x00D5: + bufpush(0x00F5); + break; + case 0x00D6: + bufpush(0x00F6); + break; + case 0x00D8: + bufpush(0x00F8); + break; + case 0x00D9: + bufpush(0x00F9); + break; + case 0x00DA: + bufpush(0x00FA); + break; + case 0x00DB: + bufpush(0x00FB); + break; + case 0x00DC: + bufpush(0x00FC); + break; + case 0x00DD: + bufpush(0x00FD); + break; + case 0x00DE: + bufpush(0x00FE); + break; + case 0x00DF: + bufpush(0x0073); + bufpush(0x0073); + break; + case 0x0100: + bufpush(0x0101); + break; + case 0x0102: + bufpush(0x0103); + break; + case 0x0104: + bufpush(0x0105); + break; + case 0x0106: + bufpush(0x0107); + break; + case 0x0108: + bufpush(0x0109); + break; + case 0x010A: + bufpush(0x010B); + break; + case 0x010C: + bufpush(0x010D); + break; + case 0x010E: + bufpush(0x010F); + break; + case 0x0110: + bufpush(0x0111); + break; + case 0x0112: + bufpush(0x0113); + break; + case 0x0114: + bufpush(0x0115); + break; + case 0x0116: + bufpush(0x0117); + break; + case 0x0118: + bufpush(0x0119); + break; + case 0x011A: + bufpush(0x011B); + break; + case 0x011C: + bufpush(0x011D); + break; + case 0x011E: + bufpush(0x011F); + break; + case 0x0120: + bufpush(0x0121); + break; + case 0x0122: + bufpush(0x0123); + break; + case 0x0124: + bufpush(0x0125); + break; + case 0x0126: + bufpush(0x0127); + break; + case 0x0128: + bufpush(0x0129); + break; + case 0x012A: + bufpush(0x012B); + break; + case 0x012C: + bufpush(0x012D); + break; + case 0x012E: + bufpush(0x012F); + break; + case 0x0130: + bufpush(0x0069); + bufpush(0x0307); + break; + case 0x0132: + bufpush(0x0133); + break; + case 0x0134: + bufpush(0x0135); + break; + case 0x0136: + bufpush(0x0137); + break; + case 0x0139: + bufpush(0x013A); + break; + case 0x013B: + bufpush(0x013C); + break; + case 0x013D: + bufpush(0x013E); + break; + case 0x013F: + bufpush(0x0140); + break; + case 0x0141: + bufpush(0x0142); + break; + case 0x0143: + bufpush(0x0144); + break; + case 0x0145: + bufpush(0x0146); + break; + case 0x0147: + bufpush(0x0148); + break; + case 0x0149: + bufpush(0x02BC); + bufpush(0x006E); + break; + case 0x014A: + bufpush(0x014B); + break; + case 0x014C: + bufpush(0x014D); + break; + case 0x014E: + bufpush(0x014F); + break; + case 0x0150: + bufpush(0x0151); + break; + case 0x0152: + bufpush(0x0153); + break; + case 0x0154: + bufpush(0x0155); + break; + case 0x0156: + bufpush(0x0157); + break; + case 0x0158: + bufpush(0x0159); + break; + case 0x015A: + bufpush(0x015B); + break; + case 0x015C: + bufpush(0x015D); + break; + case 0x015E: + bufpush(0x015F); + break; + case 0x0160: + bufpush(0x0161); + break; + case 0x0162: + bufpush(0x0163); + break; + case 0x0164: + bufpush(0x0165); + break; + case 0x0166: + bufpush(0x0167); + break; + case 0x0168: + bufpush(0x0169); + break; + case 0x016A: + bufpush(0x016B); + break; + case 0x016C: + bufpush(0x016D); + break; + case 0x016E: + bufpush(0x016F); + break; + case 0x0170: + bufpush(0x0171); + break; + case 0x0172: + bufpush(0x0173); + break; + case 0x0174: + bufpush(0x0175); + break; + case 0x0176: + bufpush(0x0177); + break; + case 0x0178: + bufpush(0x00FF); + break; + case 0x0179: + bufpush(0x017A); + break; + case 0x017B: + bufpush(0x017C); + break; + case 0x017D: + bufpush(0x017E); + break; + case 0x017F: + bufpush(0x0073); + break; + case 0x0181: + bufpush(0x0253); + break; + case 0x0182: + bufpush(0x0183); + break; + case 0x0184: + bufpush(0x0185); + break; + case 0x0186: + bufpush(0x0254); + break; + case 0x0187: + bufpush(0x0188); + break; + case 0x0189: + bufpush(0x0256); + break; + case 0x018A: + bufpush(0x0257); + break; + case 0x018B: + bufpush(0x018C); + break; + case 0x018E: + bufpush(0x01DD); + break; + case 0x018F: + bufpush(0x0259); + break; + case 0x0190: + bufpush(0x025B); + break; + case 0x0191: + bufpush(0x0192); + break; + case 0x0193: + bufpush(0x0260); + break; + case 0x0194: + bufpush(0x0263); + break; + case 0x0196: + bufpush(0x0269); + break; + case 0x0197: + bufpush(0x0268); + break; + case 0x0198: + bufpush(0x0199); + break; + case 0x019C: + bufpush(0x026F); + break; + case 0x019D: + bufpush(0x0272); + break; + case 0x019F: + bufpush(0x0275); + break; + case 0x01A0: + bufpush(0x01A1); + break; + case 0x01A2: + bufpush(0x01A3); + break; + case 0x01A4: + bufpush(0x01A5); + break; + case 0x01A6: + bufpush(0x0280); + break; + case 0x01A7: + bufpush(0x01A8); + break; + case 0x01A9: + bufpush(0x0283); + break; + case 0x01AC: + bufpush(0x01AD); + break; + case 0x01AE: + bufpush(0x0288); + break; + case 0x01AF: + bufpush(0x01B0); + break; + case 0x01B1: + bufpush(0x028A); + break; + case 0x01B2: + bufpush(0x028B); + break; + case 0x01B3: + bufpush(0x01B4); + break; + case 0x01B5: + bufpush(0x01B6); + break; + case 0x01B7: + bufpush(0x0292); + break; + case 0x01B8: + bufpush(0x01B9); + break; + case 0x01BC: + bufpush(0x01BD); + break; + case 0x01C4: + bufpush(0x01C6); + break; + case 0x01C5: + bufpush(0x01C6); + break; + case 0x01C7: + bufpush(0x01C9); + break; + case 0x01C8: + bufpush(0x01C9); + break; + case 0x01CA: + bufpush(0x01CC); + break; + case 0x01CB: + bufpush(0x01CC); + break; + case 0x01CD: + bufpush(0x01CE); + break; + case 0x01CF: + bufpush(0x01D0); + break; + case 0x01D1: + bufpush(0x01D2); + break; + case 0x01D3: + bufpush(0x01D4); + break; + case 0x01D5: + bufpush(0x01D6); + break; + case 0x01D7: + bufpush(0x01D8); + break; + case 0x01D9: + bufpush(0x01DA); + break; + case 0x01DB: + bufpush(0x01DC); + break; + case 0x01DE: + bufpush(0x01DF); + break; + case 0x01E0: + bufpush(0x01E1); + break; + case 0x01E2: + bufpush(0x01E3); + break; + case 0x01E4: + bufpush(0x01E5); + break; + case 0x01E6: + bufpush(0x01E7); + break; + case 0x01E8: + bufpush(0x01E9); + break; + case 0x01EA: + bufpush(0x01EB); + break; + case 0x01EC: + bufpush(0x01ED); + break; + case 0x01EE: + bufpush(0x01EF); + break; + case 0x01F0: + bufpush(0x006A); + bufpush(0x030C); + break; + case 0x01F1: + bufpush(0x01F3); + break; + case 0x01F2: + bufpush(0x01F3); + break; + case 0x01F4: + bufpush(0x01F5); + break; + case 0x01F6: + bufpush(0x0195); + break; + case 0x01F7: + bufpush(0x01BF); + break; + case 0x01F8: + bufpush(0x01F9); + break; + case 0x01FA: + bufpush(0x01FB); + break; + case 0x01FC: + bufpush(0x01FD); + break; + case 0x01FE: + bufpush(0x01FF); + break; + case 0x0200: + bufpush(0x0201); + break; + case 0x0202: + bufpush(0x0203); + break; + case 0x0204: + bufpush(0x0205); + break; + case 0x0206: + bufpush(0x0207); + break; + case 0x0208: + bufpush(0x0209); + break; + case 0x020A: + bufpush(0x020B); + break; + case 0x020C: + bufpush(0x020D); + break; + case 0x020E: + bufpush(0x020F); + break; + case 0x0210: + bufpush(0x0211); + break; + case 0x0212: + bufpush(0x0213); + break; + case 0x0214: + bufpush(0x0215); + break; + case 0x0216: + bufpush(0x0217); + break; + case 0x0218: + bufpush(0x0219); + break; + case 0x021A: + bufpush(0x021B); + break; + case 0x021C: + bufpush(0x021D); + break; + case 0x021E: + bufpush(0x021F); + break; + case 0x0220: + bufpush(0x019E); + break; + case 0x0222: + bufpush(0x0223); + break; + case 0x0224: + bufpush(0x0225); + break; + case 0x0226: + bufpush(0x0227); + break; + case 0x0228: + bufpush(0x0229); + break; + case 0x022A: + bufpush(0x022B); + break; + case 0x022C: + bufpush(0x022D); + break; + case 0x022E: + bufpush(0x022F); + break; + case 0x0230: + bufpush(0x0231); + break; + case 0x0232: + bufpush(0x0233); + break; + case 0x0345: + bufpush(0x03B9); + break; + case 0x0386: + bufpush(0x03AC); + break; + case 0x0388: + bufpush(0x03AD); + break; + case 0x0389: + bufpush(0x03AE); + break; + case 0x038A: + bufpush(0x03AF); + break; + case 0x038C: + bufpush(0x03CC); + break; + case 0x038E: + bufpush(0x03CD); + break; + case 0x038F: + bufpush(0x03CE); + break; + case 0x0390: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x0391: + bufpush(0x03B1); + break; + case 0x0392: + bufpush(0x03B2); + break; + case 0x0393: + bufpush(0x03B3); + break; + case 0x0394: + bufpush(0x03B4); + break; + case 0x0395: + bufpush(0x03B5); + break; + case 0x0396: + bufpush(0x03B6); + break; + case 0x0397: + bufpush(0x03B7); + break; + case 0x0398: + bufpush(0x03B8); + break; + case 0x0399: + bufpush(0x03B9); + break; + case 0x039A: + bufpush(0x03BA); + break; + case 0x039B: + bufpush(0x03BB); + break; + case 0x039C: + bufpush(0x03BC); + break; + case 0x039D: + bufpush(0x03BD); + break; + case 0x039E: + bufpush(0x03BE); + break; + case 0x039F: + bufpush(0x03BF); + break; + case 0x03A0: + bufpush(0x03C0); + break; + case 0x03A1: + bufpush(0x03C1); + break; + case 0x03A3: + bufpush(0x03C3); + break; + case 0x03A4: + bufpush(0x03C4); + break; + case 0x03A5: + bufpush(0x03C5); + break; + case 0x03A6: + bufpush(0x03C6); + break; + case 0x03A7: + bufpush(0x03C7); + break; + case 0x03A8: + bufpush(0x03C8); + break; + case 0x03A9: + bufpush(0x03C9); + break; + case 0x03AA: + bufpush(0x03CA); + break; + case 0x03AB: + bufpush(0x03CB); + break; + case 0x03B0: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x03C2: + bufpush(0x03C3); + break; + case 0x03D0: + bufpush(0x03B2); + break; + case 0x03D1: + bufpush(0x03B8); + break; + case 0x03D5: + bufpush(0x03C6); + break; + case 0x03D6: + bufpush(0x03C0); + break; + case 0x03D8: + bufpush(0x03D9); + break; + case 0x03DA: + bufpush(0x03DB); + break; + case 0x03DC: + bufpush(0x03DD); + break; + case 0x03DE: + bufpush(0x03DF); + break; + case 0x03E0: + bufpush(0x03E1); + break; + case 0x03E2: + bufpush(0x03E3); + break; + case 0x03E4: + bufpush(0x03E5); + break; + case 0x03E6: + bufpush(0x03E7); + break; + case 0x03E8: + bufpush(0x03E9); + break; + case 0x03EA: + bufpush(0x03EB); + break; + case 0x03EC: + bufpush(0x03ED); + break; + case 0x03EE: + bufpush(0x03EF); + break; + case 0x03F0: + bufpush(0x03BA); + break; + case 0x03F1: + bufpush(0x03C1); + break; + case 0x03F2: + bufpush(0x03C3); + break; + case 0x03F4: + bufpush(0x03B8); + break; + case 0x03F5: + bufpush(0x03B5); + break; + case 0x0400: + bufpush(0x0450); + break; + case 0x0401: + bufpush(0x0451); + break; + case 0x0402: + bufpush(0x0452); + break; + case 0x0403: + bufpush(0x0453); + break; + case 0x0404: + bufpush(0x0454); + break; + case 0x0405: + bufpush(0x0455); + break; + case 0x0406: + bufpush(0x0456); + break; + case 0x0407: + bufpush(0x0457); + break; + case 0x0408: + bufpush(0x0458); + break; + case 0x0409: + bufpush(0x0459); + break; + case 0x040A: + bufpush(0x045A); + break; + case 0x040B: + bufpush(0x045B); + break; + case 0x040C: + bufpush(0x045C); + break; + case 0x040D: + bufpush(0x045D); + break; + case 0x040E: + bufpush(0x045E); + break; + case 0x040F: + bufpush(0x045F); + break; + case 0x0410: + bufpush(0x0430); + break; + case 0x0411: + bufpush(0x0431); + break; + case 0x0412: + bufpush(0x0432); + break; + case 0x0413: + bufpush(0x0433); + break; + case 0x0414: + bufpush(0x0434); + break; + case 0x0415: + bufpush(0x0435); + break; + case 0x0416: + bufpush(0x0436); + break; + case 0x0417: + bufpush(0x0437); + break; + case 0x0418: + bufpush(0x0438); + break; + case 0x0419: + bufpush(0x0439); + break; + case 0x041A: + bufpush(0x043A); + break; + case 0x041B: + bufpush(0x043B); + break; + case 0x041C: + bufpush(0x043C); + break; + case 0x041D: + bufpush(0x043D); + break; + case 0x041E: + bufpush(0x043E); + break; + case 0x041F: + bufpush(0x043F); + break; + case 0x0420: + bufpush(0x0440); + break; + case 0x0421: + bufpush(0x0441); + break; + case 0x0422: + bufpush(0x0442); + break; + case 0x0423: + bufpush(0x0443); + break; + case 0x0424: + bufpush(0x0444); + break; + case 0x0425: + bufpush(0x0445); + break; + case 0x0426: + bufpush(0x0446); + break; + case 0x0427: + bufpush(0x0447); + break; + case 0x0428: + bufpush(0x0448); + break; + case 0x0429: + bufpush(0x0449); + break; + case 0x042A: + bufpush(0x044A); + break; + case 0x042B: + bufpush(0x044B); + break; + case 0x042C: + bufpush(0x044C); + break; + case 0x042D: + bufpush(0x044D); + break; + case 0x042E: + bufpush(0x044E); + break; + case 0x042F: + bufpush(0x044F); + break; + case 0x0460: + bufpush(0x0461); + break; + case 0x0462: + bufpush(0x0463); + break; + case 0x0464: + bufpush(0x0465); + break; + case 0x0466: + bufpush(0x0467); + break; + case 0x0468: + bufpush(0x0469); + break; + case 0x046A: + bufpush(0x046B); + break; + case 0x046C: + bufpush(0x046D); + break; + case 0x046E: + bufpush(0x046F); + break; + case 0x0470: + bufpush(0x0471); + break; + case 0x0472: + bufpush(0x0473); + break; + case 0x0474: + bufpush(0x0475); + break; + case 0x0476: + bufpush(0x0477); + break; + case 0x0478: + bufpush(0x0479); + break; + case 0x047A: + bufpush(0x047B); + break; + case 0x047C: + bufpush(0x047D); + break; + case 0x047E: + bufpush(0x047F); + break; + case 0x0480: + bufpush(0x0481); + break; + case 0x048A: + bufpush(0x048B); + break; + case 0x048C: + bufpush(0x048D); + break; + case 0x048E: + bufpush(0x048F); + break; + case 0x0490: + bufpush(0x0491); + break; + case 0x0492: + bufpush(0x0493); + break; + case 0x0494: + bufpush(0x0495); + break; + case 0x0496: + bufpush(0x0497); + break; + case 0x0498: + bufpush(0x0499); + break; + case 0x049A: + bufpush(0x049B); + break; + case 0x049C: + bufpush(0x049D); + break; + case 0x049E: + bufpush(0x049F); + break; + case 0x04A0: + bufpush(0x04A1); + break; + case 0x04A2: + bufpush(0x04A3); + break; + case 0x04A4: + bufpush(0x04A5); + break; + case 0x04A6: + bufpush(0x04A7); + break; + case 0x04A8: + bufpush(0x04A9); + break; + case 0x04AA: + bufpush(0x04AB); + break; + case 0x04AC: + bufpush(0x04AD); + break; + case 0x04AE: + bufpush(0x04AF); + break; + case 0x04B0: + bufpush(0x04B1); + break; + case 0x04B2: + bufpush(0x04B3); + break; + case 0x04B4: + bufpush(0x04B5); + break; + case 0x04B6: + bufpush(0x04B7); + break; + case 0x04B8: + bufpush(0x04B9); + break; + case 0x04BA: + bufpush(0x04BB); + break; + case 0x04BC: + bufpush(0x04BD); + break; + case 0x04BE: + bufpush(0x04BF); + break; + case 0x04C1: + bufpush(0x04C2); + break; + case 0x04C3: + bufpush(0x04C4); + break; + case 0x04C5: + bufpush(0x04C6); + break; + case 0x04C7: + bufpush(0x04C8); + break; + case 0x04C9: + bufpush(0x04CA); + break; + case 0x04CB: + bufpush(0x04CC); + break; + case 0x04CD: + bufpush(0x04CE); + break; + case 0x04D0: + bufpush(0x04D1); + break; + case 0x04D2: + bufpush(0x04D3); + break; + case 0x04D4: + bufpush(0x04D5); + break; + case 0x04D6: + bufpush(0x04D7); + break; + case 0x04D8: + bufpush(0x04D9); + break; + case 0x04DA: + bufpush(0x04DB); + break; + case 0x04DC: + bufpush(0x04DD); + break; + case 0x04DE: + bufpush(0x04DF); + break; + case 0x04E0: + bufpush(0x04E1); + break; + case 0x04E2: + bufpush(0x04E3); + break; + case 0x04E4: + bufpush(0x04E5); + break; + case 0x04E6: + bufpush(0x04E7); + break; + case 0x04E8: + bufpush(0x04E9); + break; + case 0x04EA: + bufpush(0x04EB); + break; + case 0x04EC: + bufpush(0x04ED); + break; + case 0x04EE: + bufpush(0x04EF); + break; + case 0x04F0: + bufpush(0x04F1); + break; + case 0x04F2: + bufpush(0x04F3); + break; + case 0x04F4: + bufpush(0x04F5); + break; + case 0x04F8: + bufpush(0x04F9); + break; + case 0x0500: + bufpush(0x0501); + break; + case 0x0502: + bufpush(0x0503); + break; + case 0x0504: + bufpush(0x0505); + break; + case 0x0506: + bufpush(0x0507); + break; + case 0x0508: + bufpush(0x0509); + break; + case 0x050A: + bufpush(0x050B); + break; + case 0x050C: + bufpush(0x050D); + break; + case 0x050E: + bufpush(0x050F); + break; + case 0x0531: + bufpush(0x0561); + break; + case 0x0532: + bufpush(0x0562); + break; + case 0x0533: + bufpush(0x0563); + break; + case 0x0534: + bufpush(0x0564); + break; + case 0x0535: + bufpush(0x0565); + break; + case 0x0536: + bufpush(0x0566); + break; + case 0x0537: + bufpush(0x0567); + break; + case 0x0538: + bufpush(0x0568); + break; + case 0x0539: + bufpush(0x0569); + break; + case 0x053A: + bufpush(0x056A); + break; + case 0x053B: + bufpush(0x056B); + break; + case 0x053C: + bufpush(0x056C); + break; + case 0x053D: + bufpush(0x056D); + break; + case 0x053E: + bufpush(0x056E); + break; + case 0x053F: + bufpush(0x056F); + break; + case 0x0540: + bufpush(0x0570); + break; + case 0x0541: + bufpush(0x0571); + break; + case 0x0542: + bufpush(0x0572); + break; + case 0x0543: + bufpush(0x0573); + break; + case 0x0544: + bufpush(0x0574); + break; + case 0x0545: + bufpush(0x0575); + break; + case 0x0546: + bufpush(0x0576); + break; + case 0x0547: + bufpush(0x0577); + break; + case 0x0548: + bufpush(0x0578); + break; + case 0x0549: + bufpush(0x0579); + break; + case 0x054A: + bufpush(0x057A); + break; + case 0x054B: + bufpush(0x057B); + break; + case 0x054C: + bufpush(0x057C); + break; + case 0x054D: + bufpush(0x057D); + break; + case 0x054E: + bufpush(0x057E); + break; + case 0x054F: + bufpush(0x057F); + break; + case 0x0550: + bufpush(0x0580); + break; + case 0x0551: + bufpush(0x0581); + break; + case 0x0552: + bufpush(0x0582); + break; + case 0x0553: + bufpush(0x0583); + break; + case 0x0554: + bufpush(0x0584); + break; + case 0x0555: + bufpush(0x0585); + break; + case 0x0556: + bufpush(0x0586); + break; + case 0x0587: + bufpush(0x0565); + bufpush(0x0582); + break; + case 0x1E00: + bufpush(0x1E01); + break; + case 0x1E02: + bufpush(0x1E03); + break; + case 0x1E04: + bufpush(0x1E05); + break; + case 0x1E06: + bufpush(0x1E07); + break; + case 0x1E08: + bufpush(0x1E09); + break; + case 0x1E0A: + bufpush(0x1E0B); + break; + case 0x1E0C: + bufpush(0x1E0D); + break; + case 0x1E0E: + bufpush(0x1E0F); + break; + case 0x1E10: + bufpush(0x1E11); + break; + case 0x1E12: + bufpush(0x1E13); + break; + case 0x1E14: + bufpush(0x1E15); + break; + case 0x1E16: + bufpush(0x1E17); + break; + case 0x1E18: + bufpush(0x1E19); + break; + case 0x1E1A: + bufpush(0x1E1B); + break; + case 0x1E1C: + bufpush(0x1E1D); + break; + case 0x1E1E: + bufpush(0x1E1F); + break; + case 0x1E20: + bufpush(0x1E21); + break; + case 0x1E22: + bufpush(0x1E23); + break; + case 0x1E24: + bufpush(0x1E25); + break; + case 0x1E26: + bufpush(0x1E27); + break; + case 0x1E28: + bufpush(0x1E29); + break; + case 0x1E2A: + bufpush(0x1E2B); + break; + case 0x1E2C: + bufpush(0x1E2D); + break; + case 0x1E2E: + bufpush(0x1E2F); + break; + case 0x1E30: + bufpush(0x1E31); + break; + case 0x1E32: + bufpush(0x1E33); + break; + case 0x1E34: + bufpush(0x1E35); + break; + case 0x1E36: + bufpush(0x1E37); + break; + case 0x1E38: + bufpush(0x1E39); + break; + case 0x1E3A: + bufpush(0x1E3B); + break; + case 0x1E3C: + bufpush(0x1E3D); + break; + case 0x1E3E: + bufpush(0x1E3F); + break; + case 0x1E40: + bufpush(0x1E41); + break; + case 0x1E42: + bufpush(0x1E43); + break; + case 0x1E44: + bufpush(0x1E45); + break; + case 0x1E46: + bufpush(0x1E47); + break; + case 0x1E48: + bufpush(0x1E49); + break; + case 0x1E4A: + bufpush(0x1E4B); + break; + case 0x1E4C: + bufpush(0x1E4D); + break; + case 0x1E4E: + bufpush(0x1E4F); + break; + case 0x1E50: + bufpush(0x1E51); + break; + case 0x1E52: + bufpush(0x1E53); + break; + case 0x1E54: + bufpush(0x1E55); + break; + case 0x1E56: + bufpush(0x1E57); + break; + case 0x1E58: + bufpush(0x1E59); + break; + case 0x1E5A: + bufpush(0x1E5B); + break; + case 0x1E5C: + bufpush(0x1E5D); + break; + case 0x1E5E: + bufpush(0x1E5F); + break; + case 0x1E60: + bufpush(0x1E61); + break; + case 0x1E62: + bufpush(0x1E63); + break; + case 0x1E64: + bufpush(0x1E65); + break; + case 0x1E66: + bufpush(0x1E67); + break; + case 0x1E68: + bufpush(0x1E69); + break; + case 0x1E6A: + bufpush(0x1E6B); + break; + case 0x1E6C: + bufpush(0x1E6D); + break; + case 0x1E6E: + bufpush(0x1E6F); + break; + case 0x1E70: + bufpush(0x1E71); + break; + case 0x1E72: + bufpush(0x1E73); + break; + case 0x1E74: + bufpush(0x1E75); + break; + case 0x1E76: + bufpush(0x1E77); + break; + case 0x1E78: + bufpush(0x1E79); + break; + case 0x1E7A: + bufpush(0x1E7B); + break; + case 0x1E7C: + bufpush(0x1E7D); + break; + case 0x1E7E: + bufpush(0x1E7F); + break; + case 0x1E80: + bufpush(0x1E81); + break; + case 0x1E82: + bufpush(0x1E83); + break; + case 0x1E84: + bufpush(0x1E85); + break; + case 0x1E86: + bufpush(0x1E87); + break; + case 0x1E88: + bufpush(0x1E89); + break; + case 0x1E8A: + bufpush(0x1E8B); + break; + case 0x1E8C: + bufpush(0x1E8D); + break; + case 0x1E8E: + bufpush(0x1E8F); + break; + case 0x1E90: + bufpush(0x1E91); + break; + case 0x1E92: + bufpush(0x1E93); + break; + case 0x1E94: + bufpush(0x1E95); + break; + case 0x1E96: + bufpush(0x0068); + bufpush(0x0331); + break; + case 0x1E97: + bufpush(0x0074); + bufpush(0x0308); + break; + case 0x1E98: + bufpush(0x0077); + bufpush(0x030A); + break; + case 0x1E99: + bufpush(0x0079); + bufpush(0x030A); + break; + case 0x1E9A: + bufpush(0x0061); + bufpush(0x02BE); + break; + case 0x1E9B: + bufpush(0x1E61); + break; + case 0x1EA0: + bufpush(0x1EA1); + break; + case 0x1EA2: + bufpush(0x1EA3); + break; + case 0x1EA4: + bufpush(0x1EA5); + break; + case 0x1EA6: + bufpush(0x1EA7); + break; + case 0x1EA8: + bufpush(0x1EA9); + break; + case 0x1EAA: + bufpush(0x1EAB); + break; + case 0x1EAC: + bufpush(0x1EAD); + break; + case 0x1EAE: + bufpush(0x1EAF); + break; + case 0x1EB0: + bufpush(0x1EB1); + break; + case 0x1EB2: + bufpush(0x1EB3); + break; + case 0x1EB4: + bufpush(0x1EB5); + break; + case 0x1EB6: + bufpush(0x1EB7); + break; + case 0x1EB8: + bufpush(0x1EB9); + break; + case 0x1EBA: + bufpush(0x1EBB); + break; + case 0x1EBC: + bufpush(0x1EBD); + break; + case 0x1EBE: + bufpush(0x1EBF); + break; + case 0x1EC0: + bufpush(0x1EC1); + break; + case 0x1EC2: + bufpush(0x1EC3); + break; + case 0x1EC4: + bufpush(0x1EC5); + break; + case 0x1EC6: + bufpush(0x1EC7); + break; + case 0x1EC8: + bufpush(0x1EC9); + break; + case 0x1ECA: + bufpush(0x1ECB); + break; + case 0x1ECC: + bufpush(0x1ECD); + break; + case 0x1ECE: + bufpush(0x1ECF); + break; + case 0x1ED0: + bufpush(0x1ED1); + break; + case 0x1ED2: + bufpush(0x1ED3); + break; + case 0x1ED4: + bufpush(0x1ED5); + break; + case 0x1ED6: + bufpush(0x1ED7); + break; + case 0x1ED8: + bufpush(0x1ED9); + break; + case 0x1EDA: + bufpush(0x1EDB); + break; + case 0x1EDC: + bufpush(0x1EDD); + break; + case 0x1EDE: + bufpush(0x1EDF); + break; + case 0x1EE0: + bufpush(0x1EE1); + break; + case 0x1EE2: + bufpush(0x1EE3); + break; + case 0x1EE4: + bufpush(0x1EE5); + break; + case 0x1EE6: + bufpush(0x1EE7); + break; + case 0x1EE8: + bufpush(0x1EE9); + break; + case 0x1EEA: + bufpush(0x1EEB); + break; + case 0x1EEC: + bufpush(0x1EED); + break; + case 0x1EEE: + bufpush(0x1EEF); + break; + case 0x1EF0: + bufpush(0x1EF1); + break; + case 0x1EF2: + bufpush(0x1EF3); + break; + case 0x1EF4: + bufpush(0x1EF5); + break; + case 0x1EF6: + bufpush(0x1EF7); + break; + case 0x1EF8: + bufpush(0x1EF9); + break; + case 0x1F08: + bufpush(0x1F00); + break; + case 0x1F09: + bufpush(0x1F01); + break; + case 0x1F0A: + bufpush(0x1F02); + break; + case 0x1F0B: + bufpush(0x1F03); + break; + case 0x1F0C: + bufpush(0x1F04); + break; + case 0x1F0D: + bufpush(0x1F05); + break; + case 0x1F0E: + bufpush(0x1F06); + break; + case 0x1F0F: + bufpush(0x1F07); + break; + case 0x1F18: + bufpush(0x1F10); + break; + case 0x1F19: + bufpush(0x1F11); + break; + case 0x1F1A: + bufpush(0x1F12); + break; + case 0x1F1B: + bufpush(0x1F13); + break; + case 0x1F1C: + bufpush(0x1F14); + break; + case 0x1F1D: + bufpush(0x1F15); + break; + case 0x1F28: + bufpush(0x1F20); + break; + case 0x1F29: + bufpush(0x1F21); + break; + case 0x1F2A: + bufpush(0x1F22); + break; + case 0x1F2B: + bufpush(0x1F23); + break; + case 0x1F2C: + bufpush(0x1F24); + break; + case 0x1F2D: + bufpush(0x1F25); + break; + case 0x1F2E: + bufpush(0x1F26); + break; + case 0x1F2F: + bufpush(0x1F27); + break; + case 0x1F38: + bufpush(0x1F30); + break; + case 0x1F39: + bufpush(0x1F31); + break; + case 0x1F3A: + bufpush(0x1F32); + break; + case 0x1F3B: + bufpush(0x1F33); + break; + case 0x1F3C: + bufpush(0x1F34); + break; + case 0x1F3D: + bufpush(0x1F35); + break; + case 0x1F3E: + bufpush(0x1F36); + break; + case 0x1F3F: + bufpush(0x1F37); + break; + case 0x1F48: + bufpush(0x1F40); + break; + case 0x1F49: + bufpush(0x1F41); + break; + case 0x1F4A: + bufpush(0x1F42); + break; + case 0x1F4B: + bufpush(0x1F43); + break; + case 0x1F4C: + bufpush(0x1F44); + break; + case 0x1F4D: + bufpush(0x1F45); + break; + case 0x1F50: + bufpush(0x03C5); + bufpush(0x0313); + break; + case 0x1F52: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0300); + break; + case 0x1F54: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0301); + break; + case 0x1F56: + bufpush(0x03C5); + bufpush(0x0313); + bufpush(0x0342); + break; + case 0x1F59: + bufpush(0x1F51); + break; + case 0x1F5B: + bufpush(0x1F53); + break; + case 0x1F5D: + bufpush(0x1F55); + break; + case 0x1F5F: + bufpush(0x1F57); + break; + case 0x1F68: + bufpush(0x1F60); + break; + case 0x1F69: + bufpush(0x1F61); + break; + case 0x1F6A: + bufpush(0x1F62); + break; + case 0x1F6B: + bufpush(0x1F63); + break; + case 0x1F6C: + bufpush(0x1F64); + break; + case 0x1F6D: + bufpush(0x1F65); + break; + case 0x1F6E: + bufpush(0x1F66); + break; + case 0x1F6F: + bufpush(0x1F67); + break; + case 0x1F80: + bufpush(0x1F00); + bufpush(0x03B9); + break; + case 0x1F81: + bufpush(0x1F01); + bufpush(0x03B9); + break; + case 0x1F82: + bufpush(0x1F02); + bufpush(0x03B9); + break; + case 0x1F83: + bufpush(0x1F03); + bufpush(0x03B9); + break; + case 0x1F84: + bufpush(0x1F04); + bufpush(0x03B9); + break; + case 0x1F85: + bufpush(0x1F05); + bufpush(0x03B9); + break; + case 0x1F86: + bufpush(0x1F06); + bufpush(0x03B9); + break; + case 0x1F87: + bufpush(0x1F07); + bufpush(0x03B9); + break; + case 0x1F88: + bufpush(0x1F00); + bufpush(0x03B9); + break; + case 0x1F89: + bufpush(0x1F01); + bufpush(0x03B9); + break; + case 0x1F8A: + bufpush(0x1F02); + bufpush(0x03B9); + break; + case 0x1F8B: + bufpush(0x1F03); + bufpush(0x03B9); + break; + case 0x1F8C: + bufpush(0x1F04); + bufpush(0x03B9); + break; + case 0x1F8D: + bufpush(0x1F05); + bufpush(0x03B9); + break; + case 0x1F8E: + bufpush(0x1F06); + bufpush(0x03B9); + break; + case 0x1F8F: + bufpush(0x1F07); + bufpush(0x03B9); + break; + case 0x1F90: + bufpush(0x1F20); + bufpush(0x03B9); + break; + case 0x1F91: + bufpush(0x1F21); + bufpush(0x03B9); + break; + case 0x1F92: + bufpush(0x1F22); + bufpush(0x03B9); + break; + case 0x1F93: + bufpush(0x1F23); + bufpush(0x03B9); + break; + case 0x1F94: + bufpush(0x1F24); + bufpush(0x03B9); + break; + case 0x1F95: + bufpush(0x1F25); + bufpush(0x03B9); + break; + case 0x1F96: + bufpush(0x1F26); + bufpush(0x03B9); + break; + case 0x1F97: + bufpush(0x1F27); + bufpush(0x03B9); + break; + case 0x1F98: + bufpush(0x1F20); + bufpush(0x03B9); + break; + case 0x1F99: + bufpush(0x1F21); + bufpush(0x03B9); + break; + case 0x1F9A: + bufpush(0x1F22); + bufpush(0x03B9); + break; + case 0x1F9B: + bufpush(0x1F23); + bufpush(0x03B9); + break; + case 0x1F9C: + bufpush(0x1F24); + bufpush(0x03B9); + break; + case 0x1F9D: + bufpush(0x1F25); + bufpush(0x03B9); + break; + case 0x1F9E: + bufpush(0x1F26); + bufpush(0x03B9); + break; + case 0x1F9F: + bufpush(0x1F27); + bufpush(0x03B9); + break; + case 0x1FA0: + bufpush(0x1F60); + bufpush(0x03B9); + break; + case 0x1FA1: + bufpush(0x1F61); + bufpush(0x03B9); + break; + case 0x1FA2: + bufpush(0x1F62); + bufpush(0x03B9); + break; + case 0x1FA3: + bufpush(0x1F63); + bufpush(0x03B9); + break; + case 0x1FA4: + bufpush(0x1F64); + bufpush(0x03B9); + break; + case 0x1FA5: + bufpush(0x1F65); + bufpush(0x03B9); + break; + case 0x1FA6: + bufpush(0x1F66); + bufpush(0x03B9); + break; + case 0x1FA7: + bufpush(0x1F67); + bufpush(0x03B9); + break; + case 0x1FA8: + bufpush(0x1F60); + bufpush(0x03B9); + break; + case 0x1FA9: + bufpush(0x1F61); + bufpush(0x03B9); + break; + case 0x1FAA: + bufpush(0x1F62); + bufpush(0x03B9); + break; + case 0x1FAB: + bufpush(0x1F63); + bufpush(0x03B9); + break; + case 0x1FAC: + bufpush(0x1F64); + bufpush(0x03B9); + break; + case 0x1FAD: + bufpush(0x1F65); + bufpush(0x03B9); + break; + case 0x1FAE: + bufpush(0x1F66); + bufpush(0x03B9); + break; + case 0x1FAF: + bufpush(0x1F67); + bufpush(0x03B9); + break; + case 0x1FB2: + bufpush(0x1F70); + bufpush(0x03B9); + break; + case 0x1FB3: + bufpush(0x03B1); + bufpush(0x03B9); + break; + case 0x1FB4: + bufpush(0x03AC); + bufpush(0x03B9); + break; + case 0x1FB6: + bufpush(0x03B1); + bufpush(0x0342); + break; + case 0x1FB7: + bufpush(0x03B1); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FB8: + bufpush(0x1FB0); + break; + case 0x1FB9: + bufpush(0x1FB1); + break; + case 0x1FBA: + bufpush(0x1F70); + break; + case 0x1FBB: + bufpush(0x1F71); + break; + case 0x1FBC: + bufpush(0x03B1); + bufpush(0x03B9); + break; + case 0x1FBE: + bufpush(0x03B9); + break; + case 0x1FC2: + bufpush(0x1F74); + bufpush(0x03B9); + break; + case 0x1FC3: + bufpush(0x03B7); + bufpush(0x03B9); + break; + case 0x1FC4: + bufpush(0x03AE); + bufpush(0x03B9); + break; + case 0x1FC6: + bufpush(0x03B7); + bufpush(0x0342); + break; + case 0x1FC7: + bufpush(0x03B7); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FC8: + bufpush(0x1F72); + break; + case 0x1FC9: + bufpush(0x1F73); + break; + case 0x1FCA: + bufpush(0x1F74); + break; + case 0x1FCB: + bufpush(0x1F75); + break; + case 0x1FCC: + bufpush(0x03B7); + bufpush(0x03B9); + break; + case 0x1FD2: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0300); + break; + case 0x1FD3: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x1FD6: + bufpush(0x03B9); + bufpush(0x0342); + break; + case 0x1FD7: + bufpush(0x03B9); + bufpush(0x0308); + bufpush(0x0342); + break; + case 0x1FD8: + bufpush(0x1FD0); + break; + case 0x1FD9: + bufpush(0x1FD1); + break; + case 0x1FDA: + bufpush(0x1F76); + break; + case 0x1FDB: + bufpush(0x1F77); + break; + case 0x1FE2: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0300); + break; + case 0x1FE3: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0301); + break; + case 0x1FE4: + bufpush(0x03C1); + bufpush(0x0313); + break; + case 0x1FE6: + bufpush(0x03C5); + bufpush(0x0342); + break; + case 0x1FE7: + bufpush(0x03C5); + bufpush(0x0308); + bufpush(0x0342); + break; + case 0x1FE8: + bufpush(0x1FE0); + break; + case 0x1FE9: + bufpush(0x1FE1); + break; + case 0x1FEA: + bufpush(0x1F7A); + break; + case 0x1FEB: + bufpush(0x1F7B); + break; + case 0x1FEC: + bufpush(0x1FE5); + break; + case 0x1FF2: + bufpush(0x1F7C); + bufpush(0x03B9); + break; + case 0x1FF3: + bufpush(0x03C9); + bufpush(0x03B9); + break; + case 0x1FF4: + bufpush(0x03CE); + bufpush(0x03B9); + break; + case 0x1FF6: + bufpush(0x03C9); + bufpush(0x0342); + break; + case 0x1FF7: + bufpush(0x03C9); + bufpush(0x0342); + bufpush(0x03B9); + break; + case 0x1FF8: + bufpush(0x1F78); + break; + case 0x1FF9: + bufpush(0x1F79); + break; + case 0x1FFA: + bufpush(0x1F7C); + break; + case 0x1FFB: + bufpush(0x1F7D); + break; + case 0x1FFC: + bufpush(0x03C9); + bufpush(0x03B9); + break; + case 0x2126: + bufpush(0x03C9); + break; + case 0x212A: + bufpush(0x006B); + break; + case 0x212B: + bufpush(0x00E5); + break; + case 0x2160: + bufpush(0x2170); + break; + case 0x2161: + bufpush(0x2171); + break; + case 0x2162: + bufpush(0x2172); + break; + case 0x2163: + bufpush(0x2173); + break; + case 0x2164: + bufpush(0x2174); + break; + case 0x2165: + bufpush(0x2175); + break; + case 0x2166: + bufpush(0x2176); + break; + case 0x2167: + bufpush(0x2177); + break; + case 0x2168: + bufpush(0x2178); + break; + case 0x2169: + bufpush(0x2179); + break; + case 0x216A: + bufpush(0x217A); + break; + case 0x216B: + bufpush(0x217B); + break; + case 0x216C: + bufpush(0x217C); + break; + case 0x216D: + bufpush(0x217D); + break; + case 0x216E: + bufpush(0x217E); + break; + case 0x216F: + bufpush(0x217F); + break; + case 0x24B6: + bufpush(0x24D0); + break; + case 0x24B7: + bufpush(0x24D1); + break; + case 0x24B8: + bufpush(0x24D2); + break; + case 0x24B9: + bufpush(0x24D3); + break; + case 0x24BA: + bufpush(0x24D4); + break; + case 0x24BB: + bufpush(0x24D5); + break; + case 0x24BC: + bufpush(0x24D6); + break; + case 0x24BD: + bufpush(0x24D7); + break; + case 0x24BE: + bufpush(0x24D8); + break; + case 0x24BF: + bufpush(0x24D9); + break; + case 0x24C0: + bufpush(0x24DA); + break; + case 0x24C1: + bufpush(0x24DB); + break; + case 0x24C2: + bufpush(0x24DC); + break; + case 0x24C3: + bufpush(0x24DD); + break; + case 0x24C4: + bufpush(0x24DE); + break; + case 0x24C5: + bufpush(0x24DF); + break; + case 0x24C6: + bufpush(0x24E0); + break; + case 0x24C7: + bufpush(0x24E1); + break; + case 0x24C8: + bufpush(0x24E2); + break; + case 0x24C9: + bufpush(0x24E3); + break; + case 0x24CA: + bufpush(0x24E4); + break; + case 0x24CB: + bufpush(0x24E5); + break; + case 0x24CC: + bufpush(0x24E6); + break; + case 0x24CD: + bufpush(0x24E7); + break; + case 0x24CE: + bufpush(0x24E8); + break; + case 0x24CF: + bufpush(0x24E9); + break; + case 0xFB00: + bufpush(0x0066); + bufpush(0x0066); + break; + case 0xFB01: + bufpush(0x0066); + bufpush(0x0069); + break; + case 0xFB02: + bufpush(0x0066); + bufpush(0x006C); + break; + case 0xFB03: + bufpush(0x0066); + bufpush(0x0066); + bufpush(0x0069); + break; + case 0xFB04: + bufpush(0x0066); + bufpush(0x0066); + bufpush(0x006C); + break; + case 0xFB05: + bufpush(0x0073); + bufpush(0x0074); + break; + case 0xFB06: + bufpush(0x0073); + bufpush(0x0074); + break; + case 0xFB13: + bufpush(0x0574); + bufpush(0x0576); + break; + case 0xFB14: + bufpush(0x0574); + bufpush(0x0565); + break; + case 0xFB15: + bufpush(0x0574); + bufpush(0x056B); + break; + case 0xFB16: + bufpush(0x057E); + bufpush(0x0576); + break; + case 0xFB17: + bufpush(0x0574); + bufpush(0x056D); + break; + case 0xFF21: + bufpush(0xFF41); + break; + case 0xFF22: + bufpush(0xFF42); + break; + case 0xFF23: + bufpush(0xFF43); + break; + case 0xFF24: + bufpush(0xFF44); + break; + case 0xFF25: + bufpush(0xFF45); + break; + case 0xFF26: + bufpush(0xFF46); + break; + case 0xFF27: + bufpush(0xFF47); + break; + case 0xFF28: + bufpush(0xFF48); + break; + case 0xFF29: + bufpush(0xFF49); + break; + case 0xFF2A: + bufpush(0xFF4A); + break; + case 0xFF2B: + bufpush(0xFF4B); + break; + case 0xFF2C: + bufpush(0xFF4C); + break; + case 0xFF2D: + bufpush(0xFF4D); + break; + case 0xFF2E: + bufpush(0xFF4E); + break; + case 0xFF2F: + bufpush(0xFF4F); + break; + case 0xFF30: + bufpush(0xFF50); + break; + case 0xFF31: + bufpush(0xFF51); + break; + case 0xFF32: + bufpush(0xFF52); + break; + case 0xFF33: + bufpush(0xFF53); + break; + case 0xFF34: + bufpush(0xFF54); + break; + case 0xFF35: + bufpush(0xFF55); + break; + case 0xFF36: + bufpush(0xFF56); + break; + case 0xFF37: + bufpush(0xFF57); + break; + case 0xFF38: + bufpush(0xFF58); + break; + case 0xFF39: + bufpush(0xFF59); + break; + case 0xFF3A: + bufpush(0xFF5A); + break; + case 0x10400: + bufpush(0x10428); + break; + case 0x10401: + bufpush(0x10429); + break; + case 0x10402: + bufpush(0x1042A); + break; + case 0x10403: + bufpush(0x1042B); + break; + case 0x10404: + bufpush(0x1042C); + break; + case 0x10405: + bufpush(0x1042D); + break; + case 0x10406: + bufpush(0x1042E); + break; + case 0x10407: + bufpush(0x1042F); + break; + case 0x10408: + bufpush(0x10430); + break; + case 0x10409: + bufpush(0x10431); + break; + case 0x1040A: + bufpush(0x10432); + break; + case 0x1040B: + bufpush(0x10433); + break; + case 0x1040C: + bufpush(0x10434); + break; + case 0x1040D: + bufpush(0x10435); + break; + case 0x1040E: + bufpush(0x10436); + break; + case 0x1040F: + bufpush(0x10437); + break; + case 0x10410: + bufpush(0x10438); + break; + case 0x10411: + bufpush(0x10439); + break; + case 0x10412: + bufpush(0x1043A); + break; + case 0x10413: + bufpush(0x1043B); + break; + case 0x10414: + bufpush(0x1043C); + break; + case 0x10415: + bufpush(0x1043D); + break; + case 0x10416: + bufpush(0x1043E); + break; + case 0x10417: + bufpush(0x1043F); + break; + case 0x10418: + bufpush(0x10440); + break; + case 0x10419: + bufpush(0x10441); + break; + case 0x1041A: + bufpush(0x10442); + break; + case 0x1041B: + bufpush(0x10443); + break; + case 0x1041C: + bufpush(0x10444); + break; + case 0x1041D: + bufpush(0x10445); + break; + case 0x1041E: + bufpush(0x10446); + break; + case 0x1041F: + bufpush(0x10447); + break; + case 0x10420: + bufpush(0x10448); + break; + case 0x10421: + bufpush(0x10449); + break; + case 0x10422: + bufpush(0x1044A); + break; + case 0x10423: + bufpush(0x1044B); + break; + case 0x10424: + bufpush(0x1044C); + break; + case 0x10425: + bufpush(0x1044D); + break; + default: + bufpush(c); + } diff --git a/cmark/chunk.h b/cmark/chunk.h new file mode 100644 --- /dev/null +++ b/cmark/chunk.h @@ -0,0 +1,110 @@ +#ifndef CMARK_CHUNK_H +#define CMARK_CHUNK_H + +#include +#include +#include +#include "cmark_ctype.h" +#include "buffer.h" + +typedef struct { + unsigned char *data; + int len; + int alloc; // also implies a NULL-terminated string +} cmark_chunk; + +static inline void cmark_chunk_free(cmark_chunk *c) +{ + if (c->alloc) + free(c->data); + + c->data = NULL; + c->alloc = 0; + c->len = 0; +} + +static inline void cmark_chunk_ltrim(cmark_chunk *c) +{ + assert(!c->alloc); + + while (c->len && cmark_isspace(c->data[0])) { + c->data++; + c->len--; + } +} + +static inline void cmark_chunk_rtrim(cmark_chunk *c) +{ + while (c->len > 0) { + if (!cmark_isspace(c->data[c->len - 1])) + break; + + c->len--; + } +} + +static inline void cmark_chunk_trim(cmark_chunk *c) +{ + cmark_chunk_ltrim(c); + cmark_chunk_rtrim(c); +} + +static inline int cmark_chunk_strchr(cmark_chunk *ch, int c, int offset) +{ + const unsigned char *p = (unsigned char *)memchr(ch->data + offset, c, ch->len - offset); + return p ? (int)(p - ch->data) : ch->len; +} + +static inline const char *cmark_chunk_to_cstr(cmark_chunk *c) +{ + unsigned char *str; + + if (c->alloc) { + return (char *)c->data; + } + str = (unsigned char *)malloc(c->len + 1); + if(str != NULL) { + memcpy(str, c->data, c->len); + str[c->len] = 0; + } + c->data = str; + c->alloc = 1; + + return (char *)str; +} + +static inline void cmark_chunk_set_cstr(cmark_chunk *c, const char *str) +{ + if (c->alloc) { + free(c->data); + } + c->len = strlen(str); + c->data = (unsigned char *)malloc(c->len + 1); + c->alloc = 1; + memcpy(c->data, str, c->len + 1); +} + +static inline cmark_chunk cmark_chunk_literal(const char *data) +{ + cmark_chunk c = {(unsigned char *)data, data ? strlen(data) : 0, 0}; + return c; +} + +static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, int pos, int len) +{ + cmark_chunk c = {ch->data + pos, len, 0}; + return c; +} + +static inline cmark_chunk cmark_chunk_buf_detach(cmark_strbuf *buf) +{ + cmark_chunk c; + + c.len = buf->size; + c.data = cmark_strbuf_detach(buf); + c.alloc = 1; + + return c; +} + +#endif diff --git a/cmark/cmark.c b/cmark/cmark.c new file mode 100644 --- /dev/null +++ b/cmark/cmark.c @@ -0,0 +1,24 @@ +#include +#include +#include +#include "node.h" +#include "houdini.h" +#include "cmark.h" +#include "buffer.h" + +const int cmark_version = CMARK_VERSION; +const char cmark_version_string[] = CMARK_VERSION_STRING; + +char *cmark_markdown_to_html(const char *text, int len, int options) +{ + cmark_node *doc; + char *result; + + doc = cmark_parse_document(text, len, options); + + result = cmark_render_html(doc, options); + cmark_node_free(doc); + + return result; +} + diff --git a/cmark/cmark.h b/cmark/cmark.h new file mode 100644 --- /dev/null +++ b/cmark/cmark.h @@ -0,0 +1,561 @@ +#ifndef CMARK_H +#define CMARK_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** # NAME + * + * **cmark** - CommonMark parsing, manipulating, and rendering + */ + +/** # DESCRIPTION + * + * ## Simple Interface + */ + +/** Convert 'text' (assumed to be a UTF-8 encoded string with length + * 'len' from CommonMark Markdown to HTML, returning a null-terminated, + * UTF-8-encoded string. + */ +CMARK_EXPORT +char *cmark_markdown_to_html(const char *text, int len, int options); + +/** ## Node Structure + */ + +typedef enum { + /* Error status */ + CMARK_NODE_NONE, + + /* Block */ + CMARK_NODE_DOCUMENT, + CMARK_NODE_BLOCK_QUOTE, + CMARK_NODE_LIST, + CMARK_NODE_ITEM, + CMARK_NODE_CODE_BLOCK, + CMARK_NODE_HTML, + CMARK_NODE_PARAGRAPH, + CMARK_NODE_HEADER, + CMARK_NODE_HRULE, + + CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT, + CMARK_NODE_LAST_BLOCK = CMARK_NODE_HRULE, + + /* Inline */ + CMARK_NODE_TEXT, + CMARK_NODE_SOFTBREAK, + CMARK_NODE_LINEBREAK, + CMARK_NODE_CODE, + CMARK_NODE_INLINE_HTML, + CMARK_NODE_EMPH, + CMARK_NODE_STRONG, + CMARK_NODE_LINK, + CMARK_NODE_IMAGE, + + CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT, + CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE, +} cmark_node_type; + + +typedef enum { + CMARK_NO_LIST, + CMARK_BULLET_LIST, + CMARK_ORDERED_LIST +} cmark_list_type; + +typedef enum { + CMARK_NO_DELIM, + CMARK_PERIOD_DELIM, + CMARK_PAREN_DELIM +} cmark_delim_type; + +typedef struct cmark_node cmark_node; +typedef struct cmark_parser cmark_parser; +typedef struct cmark_iter cmark_iter; + +typedef enum { + CMARK_EVENT_NONE, + CMARK_EVENT_DONE, + CMARK_EVENT_ENTER, + CMARK_EVENT_EXIT +} cmark_event_type; + +/** + * ## Creating and Destroying Nodes + */ + +/** Creates a new node of type 'type'. Note that the node may have + * other required properties, which it is the caller's responsibility + * to assign. + */ +CMARK_EXPORT cmark_node* +cmark_node_new(cmark_node_type type); + +/** Frees the memory allocated for a node. + */ +CMARK_EXPORT void +cmark_node_free(cmark_node *node); + +/** + * ## Tree Traversal + */ + +/** Returns the next node in the sequence after 'node', or NULL if + * there is none. + */ +CMARK_EXPORT cmark_node* +cmark_node_next(cmark_node *node); + +/** Returns the previous node in the sequence after 'node', or NULL if + * there is none. + */ +CMARK_EXPORT cmark_node* +cmark_node_previous(cmark_node *node); + +/** Returns the parent of 'node', or NULL if there is none. + */ +CMARK_EXPORT cmark_node* +cmark_node_parent(cmark_node *node); + +/** Returns the first child of 'node', or NULL if 'node' has no children. + */ +CMARK_EXPORT cmark_node* +cmark_node_first_child(cmark_node *node); + +/** Returns the last child of 'node', or NULL if 'node' has no children. + */ +CMARK_EXPORT cmark_node* +cmark_node_last_child(cmark_node *node); + +/** + * ## Iterator + * + * An iterator will walk through a tree of nodes, starting from a root + * node, returning one node at a time, together with information about + * whether the node is being entered or exited. The iterator will + * first descend to a child node, if there is one. When there is no + * child, the iterator will go to the next sibling. When there is no + * next sibling, the iterator will return to the parent (but with + * a 'cmark_event_type' of `CMARK_EVENT_EXIT`). The iterator will + * return `CMARK_EVENT_DONE` when it reaches the root node again. + * One natural application is an HTML renderer, where an `ENTER` event + * outputs an open tag and an `EXIT` event outputs a close tag. + * An iterator might also be used to transform an AST in some systematic + * way, for example, turning all level-3 headers into regular paragraphs. + * + * void + * usage_example(cmark_node *root) { + * cmark_event_type ev_type; + * cmark_iter *iter = cmark_iter_new(root); + * + * while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + * cmark_node *cur = cmark_iter_get_node(iter); + * // Do something with `cur` and `ev_type` + * } + * + * cmark_iter_free(iter); + * } + * + * Iterators will never return `EXIT` events for leaf nodes, which are nodes + * of type: + * + * * CMARK_NODE_HTML + * * CMARK_NODE_HRULE + * * CMARK_NODE_CODE_BLOCK + * * CMARK_NODE_TEXT + * * CMARK_NODE_SOFTBREAK + * * CMARK_NODE_LINEBREAK + * * CMARK_NODE_CODE + * * CMARK_NODE_INLINE_HTML + * + * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for + * leaf nodes. + */ + +/** Creates a new iterator starting at 'root'. The current node and event + * type are undefined until `cmark_iter_next` is called for the first time. + */ +CMARK_EXPORT +cmark_iter* +cmark_iter_new(cmark_node *root); + +/** Frees the memory allocated for an iterator. + */ +CMARK_EXPORT +void +cmark_iter_free(cmark_iter *iter); + +/** Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`, + * `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`). + */ +CMARK_EXPORT +cmark_event_type +cmark_iter_next(cmark_iter *iter); + +/** Returns the current node. + */ +CMARK_EXPORT +cmark_node* +cmark_iter_get_node(cmark_iter *iter); + +/** Returns the current event type. + */ +CMARK_EXPORT +cmark_event_type +cmark_iter_get_event_type(cmark_iter *iter); + +/** Returns the root node. + */ +CMARK_EXPORT +cmark_node* +cmark_iter_get_root(cmark_iter *iter); + +/** Resets the iterator so that the current node is 'current' and + * the event type is 'event_type'. The new current node must be a + * descendant of the root node or the root node itself. + */ +CMARK_EXPORT +void +cmark_iter_reset(cmark_iter *iter, cmark_node *current, + cmark_event_type event_type); + +/** + * ## Accessors + */ + +/** Returns the user data of 'node'. + */ +CMARK_EXPORT void* +cmark_node_get_user_data(cmark_node *node); + +/** Sets arbitrary user data for 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_user_data(cmark_node *node, void *user_data); + +/** Returns the type of 'node', or `CMARK_NODE_NONE` on error. + */ +CMARK_EXPORT cmark_node_type +cmark_node_get_type(cmark_node *node); + +/** Like 'cmark_node_get_type', but returns a string representation + of the type, or `""`. + */ +CMARK_EXPORT +const char* +cmark_node_get_type_string(cmark_node *node); + +/** Returns the string contents of 'node', or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_literal(cmark_node *node); + +/** Sets the string contents of 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_literal(cmark_node *node, const char *content); + +/** Returns the header level of 'node', or 0 if 'node' is not a header. + */ +CMARK_EXPORT int +cmark_node_get_header_level(cmark_node *node); + +/** Sets the header level of 'node', returning 1 on success and 0 on error. + */ +CMARK_EXPORT int +cmark_node_set_header_level(cmark_node *node, int level); + +/** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node' + * is not a list. + */ +CMARK_EXPORT cmark_list_type +cmark_node_get_list_type(cmark_node *node); + +/** Sets the list type of 'node', returning 1 on success and 0 on error. + */ +CMARK_EXPORT int +cmark_node_set_list_type(cmark_node *node, cmark_list_type type); + +/** Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node' + * is not a list. + */ +CMARK_EXPORT cmark_delim_type +cmark_node_get_list_delim(cmark_node *node); + +/** Sets the list delimiter type of 'node', returning 1 on success and 0 + * on error. + */ +CMARK_EXPORT int +cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim); + +/** Returns starting number of 'node', if it is an ordered list, otherwise 0. + */ +CMARK_EXPORT int +cmark_node_get_list_start(cmark_node *node); + +/** Sets starting number of 'node', if it is an ordered list. Returns 1 + * on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_list_start(cmark_node *node, int start); + +/** Returns 1 if 'node' is a tight list, 0 otherwise. + */ +CMARK_EXPORT int +cmark_node_get_list_tight(cmark_node *node); + +/** Sets the "tightness" of a list. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_list_tight(cmark_node *node, int tight); + +/** Returns the info string from a fenced code block, or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_fence_info(cmark_node *node); + +/** Sets the info string in a fenced code block, returning 1 on + * success and 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_fence_info(cmark_node *node, const char *info); + +/** Gets the URL of a link or image 'node', or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_url(cmark_node *node); + +/** Sets the URL of a link or image 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_url(cmark_node *node, const char *url); + +/** Gets the title of a link or image 'node', or NULL if none. + */ +CMARK_EXPORT const char* +cmark_node_get_title(cmark_node *node); + +/** Sets the title of a link or image 'node'. Returns 1 on success, + * 0 on failure. + */ +CMARK_EXPORT int +cmark_node_set_title(cmark_node *node, const char *title); + +/** Returns the line on which 'node' begins. + */ +CMARK_EXPORT int +cmark_node_get_start_line(cmark_node *node); + +/** Returns the column at which 'node' begins. + */ +CMARK_EXPORT int +cmark_node_get_start_column(cmark_node *node); + +/** Returns the line on which 'node' ends. + */ +CMARK_EXPORT int +cmark_node_get_end_line(cmark_node *node); + +/** Returns the column at which 'node' ends. + */ +CMARK_EXPORT int +cmark_node_get_end_column(cmark_node *node); + +/** + * ## Tree Manipulation + */ + +/** Unlinks a 'node', removing it from the tree, but not freeing its + * memory. (Use 'cmark_node_free' for that.) + */ +CMARK_EXPORT void +cmark_node_unlink(cmark_node *node); + +/** Inserts 'sibling' before 'node'. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_insert_before(cmark_node *node, cmark_node *sibling); + +/** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_insert_after(cmark_node *node, cmark_node *sibling); + +/** Adds 'child' to the beginning of the children of 'node'. + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_prepend_child(cmark_node *node, cmark_node *child); + +/** Adds 'child' to the end of the children of 'node'. + * Returns 1 on success, 0 on failure. + */ +CMARK_EXPORT int +cmark_node_append_child(cmark_node *node, cmark_node *child); + +/** Consolidates adjacent text nodes. + */ +CMARK_EXPORT void +cmark_consolidate_text_nodes(cmark_node *root); + +/** + * ## Parsing + * + * Simple interface: + * + * cmark_node *document = cmark_parse_document("Hello *world*", 12, + * CMARK_OPT_DEFAULT); + * + * Streaming interface: + * + * cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT); + * FILE *fp = fopen("myfile.md", "r"); + * while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { + * cmark_parser_feed(parser, buffer, bytes); + * if (bytes < sizeof(buffer)) { + * break; + * } + * } + * document = cmark_parser_finish(parser); + * cmark_parser_free(parser); + */ + +/** Creates a new parser object. + */ +CMARK_EXPORT +cmark_parser *cmark_parser_new(int options); + +/** Frees memory allocated for a parser object. + */ +CMARK_EXPORT +void cmark_parser_free(cmark_parser *parser); + +/** Feeds a string of length 'len' to 'parser'. + */ +CMARK_EXPORT +void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len); + +/** Finish parsing and return a pointer to a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parser_finish(cmark_parser *parser); + +/** Parse a CommonMark document in 'buffer' of length 'len'. + * Returns a pointer to a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parse_document(const char *buffer, size_t len, int options); + +/** Parse a CommonMark document in file 'f', returning a pointer to + * a tree of nodes. + */ +CMARK_EXPORT +cmark_node *cmark_parse_file(FILE *f, int options); + +/** + * ## Rendering + */ + +/** Render a 'node' tree as XML. + */ +CMARK_EXPORT +char *cmark_render_xml(cmark_node *root, int options); + +/** Render a 'node' tree as an HTML fragment. It is up to the user + * to add an appropriate header and footer. + */ +CMARK_EXPORT +char *cmark_render_html(cmark_node *root, int options); + +/** Render a 'node' tree as a groff man page, without the header. + */ +CMARK_EXPORT +char *cmark_render_man(cmark_node *root, int options); + +/** Default writer options. + */ +#define CMARK_OPT_DEFAULT 0 + +/** Include a `data-sourcepos` attribute on all block elements. + */ +#define CMARK_OPT_SOURCEPOS 1 + +/** Render `softbreak` elements as hard line breaks. + */ +#define CMARK_OPT_HARDBREAKS 2 + +/** Normalize tree by consolidating adjacent text nodes. + */ +#define CMARK_OPT_NORMALIZE 4 + +/** Convert straight quotes to curly, --- to em dashes, -- to en dashes. + */ +#define CMARK_OPT_SMART 8 + +/** + * ## Version information + */ + +/** The library version as integer for runtime checks. Also available as + * macro CMARK_VERSION for compile time checks. + * + * * Bits 16-23 contain the major version. + * * Bits 8-15 contain the minor version. + * * Bits 0-7 contain the patchlevel. + * + * In hexadecimal format, the number 0x010203 represents version 1.2.3. + */ +CMARK_EXPORT +extern const int cmark_version; + +/** The library version string for runtime checks. Also available as + * macro CMARK_VERSION_STRING for compile time checks. + */ +CMARK_EXPORT +extern const char cmark_version_string[]; + +/** # AUTHORS + * + * John MacFarlane, Vicent Marti, Kārlis Gaņģis, Nick Wellnhofer. + */ + +#ifndef CMARK_NO_SHORT_NAMES +#define NODE_DOCUMENT CMARK_NODE_DOCUMENT +#define NODE_BLOCK_QUOTE CMARK_NODE_BLOCK_QUOTE +#define NODE_LIST CMARK_NODE_LIST +#define NODE_ITEM CMARK_NODE_ITEM +#define NODE_CODE_BLOCK CMARK_NODE_CODE_BLOCK +#define NODE_HTML CMARK_NODE_HTML +#define NODE_PARAGRAPH CMARK_NODE_PARAGRAPH +#define NODE_HEADER CMARK_NODE_HEADER +#define NODE_HRULE CMARK_NODE_HRULE +#define NODE_TEXT CMARK_NODE_TEXT +#define NODE_SOFTBREAK CMARK_NODE_SOFTBREAK +#define NODE_LINEBREAK CMARK_NODE_LINEBREAK +#define NODE_CODE CMARK_NODE_CODE +#define NODE_INLINE_HTML CMARK_NODE_INLINE_HTML +#define NODE_EMPH CMARK_NODE_EMPH +#define NODE_STRONG CMARK_NODE_STRONG +#define NODE_LINK CMARK_NODE_LINK +#define NODE_IMAGE CMARK_NODE_IMAGE +#define NODE_LINK_LABEL CMARK_NODE_LINK_LABEL +#define BULLET_LIST CMARK_BULLET_LIST +#define ORDERED_LIST CMARK_ORDERED_LIST +#define PERIOD_DELIM CMARK_PERIOD_DELIM +#define PAREN_DELIM CMARK_PAREN_DELIM +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/cmark_ctype.c b/cmark/cmark_ctype.c new file mode 100644 --- /dev/null +++ b/cmark/cmark_ctype.c @@ -0,0 +1,53 @@ +#include + +#include "cmark_ctype.h" + +/** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other + */ +static const int8_t cmark_ctype_class[256] = { + /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ + /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, + /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, + /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0, + /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/** + * Returns 1 if c is a "whitespace" character as defined by the spec. + */ +int cmark_isspace(char c) +{ + return cmark_ctype_class[(int8_t)c] == 1; +} + +/** + * Returns 1 if c is an ascii punctuation character. + */ +int cmark_ispunct(char c) +{ + return cmark_ctype_class[(int8_t)c] == 2; +} + +int cmark_isalnum(char c) +{ + int8_t result; + result = cmark_ctype_class[(int8_t)c]; + return (result == 3 || result == 4); +} + +int cmark_isdigit(char c) +{ + return cmark_ctype_class[(int8_t)c] == 3; +} diff --git a/cmark/cmark_ctype.h b/cmark/cmark_ctype.h new file mode 100644 --- /dev/null +++ b/cmark/cmark_ctype.h @@ -0,0 +1,24 @@ +#ifndef CMARK_CMARK_CTYPE_H +#define CMARK_CMARK_CTYPE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** Locale-independent versions of functions from ctype.h. + * We want cmark to behave the same no matter what the system locale. + */ + +int cmark_isspace(char c); + +int cmark_ispunct(char c); + +int cmark_isalnum(char c); + +int cmark_isdigit(char c); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/cmark_export.h b/cmark/cmark_export.h new file mode 100644 --- /dev/null +++ b/cmark/cmark_export.h @@ -0,0 +1,35 @@ + +#ifndef CMARK_EXPORT_H +#define CMARK_EXPORT_H + +#ifdef CMARK_STATIC_DEFINE +# define CMARK_EXPORT +# define CMARK_NO_EXPORT +#else +# ifndef CMARK_EXPORT +# ifdef libcmark_EXPORTS + /* We are building this library */ +# define CMARK_EXPORT __attribute__((visibility("default"))) +# else + /* We are using this library */ +# define CMARK_EXPORT __attribute__((visibility("default"))) +# endif +# endif + +# ifndef CMARK_NO_EXPORT +# define CMARK_NO_EXPORT __attribute__((visibility("hidden"))) +# endif +#endif + +#ifndef CMARK_DEPRECATED +# define CMARK_DEPRECATED __attribute__ ((__deprecated__)) +# define CMARK_DEPRECATED_EXPORT CMARK_EXPORT __attribute__ ((__deprecated__)) +# define CMARK_DEPRECATED_NO_EXPORT CMARK_NO_EXPORT __attribute__ ((__deprecated__)) +#endif + +#define DEFINE_NO_DEPRECATED 0 +#if DEFINE_NO_DEPRECATED +# define CMARK_NO_DEPRECATED +#endif + +#endif diff --git a/cmark/cmark_version.h b/cmark/cmark_version.h new file mode 100644 --- /dev/null +++ b/cmark/cmark_version.h @@ -0,0 +1,7 @@ +#ifndef CMARK_VERSION_H +#define CMARK_VERSION_H + +#define CMARK_VERSION ((0 << 16) | (18 << 8) | 1) +#define CMARK_VERSION_STRING "0.18.1" + +#endif diff --git a/cmark/config.h b/cmark/config.h new file mode 100644 --- /dev/null +++ b/cmark/config.h @@ -0,0 +1,23 @@ +#define HAVE_STDBOOL_H + +#ifdef HAVE_STDBOOL_H + #include +#elif !defined(__cplusplus) + typedef char bool; +#endif + +/* #undef HAVE___BUILTIN_EXPECT */ + +#define HAVE___ATTRIBUTE__ + +#ifdef HAVE___ATTRIBUTE__ + #define CMARK_ATTRIBUTE(list) __attribute__ (list) +#else + #define CMARK_ATTRIBUTE(list) +#endif + +#define HAVE_VA_COPY + +#ifndef HAVE_VA_COPY + #define va_copy(dest, src) ((dest) = (src)) +#endif diff --git a/cmark/debug.h b/cmark/debug.h new file mode 100644 --- /dev/null +++ b/cmark/debug.h @@ -0,0 +1,36 @@ +#ifndef CMARK_DEBUG_H +#define CMARK_DEBUG_H +#include +#include +#include + +#ifdef NDEBUG +#define debug(M, ...) +#else +#define debug(M, ...) \ + fprintf(stderr, "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__) +#endif + +#define clean_errno() (errno == 0 ? "None" : strerror(errno)) + +#define log_err(M, ...) \ + fprintf(stderr, "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \ + clean_errno(), ##__VA_ARGS__) + +#define log_warn(M, ...) \ + fprintf(stderr, "[WARN] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \ + clean_errno(), ##__VA_ARGS__) + +#define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%d) " M "\n", __FILE__, \ + __LINE__, ##__VA_ARGS__) + +#define check(A, M, ...) \ + if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto error; } + +#define sentinel(M, ...) \ + { log_err(M, ##__VA_ARGS__); errno=0; goto error; } + +#define check_debug(A, M, ...) \ + if(!(A)) { debug(M, ##__VA_ARGS__); errno=0; goto error; } + +#endif diff --git a/cmark/houdini.h b/cmark/houdini.h new file mode 100644 --- /dev/null +++ b/cmark/houdini.h @@ -0,0 +1,52 @@ +#ifndef CMARK_HOUDINI_H +#define CMARK_HOUDINI_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "config.h" +#include "buffer.h" + +#ifdef HAVE___BUILTIN_EXPECT +# define likely(x) __builtin_expect((x),1) +# define unlikely(x) __builtin_expect((x),0) +#else +# define likely(x) (x) +# define unlikely(x) (x) +#endif + +#ifdef HOUDINI_USE_LOCALE +# define _isxdigit(c) isxdigit(c) +# define _isdigit(c) isdigit(c) +#else +/* + * Helper _isdigit methods -- do not trust the current locale + * */ +# define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL) +# define _isdigit(c) ((c) >= '0' && (c) <= '9') +#endif + +#define HOUDINI_ESCAPED_SIZE(x) (((x) * 12) / 10) +#define HOUDINI_UNESCAPED_SIZE(x) (x) + +extern size_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure); +extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_xml(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_url(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_unescape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_unescape_url(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_escape_js(cmark_strbuf *ob, const uint8_t *src, size_t size); +extern int houdini_unescape_js(cmark_strbuf *ob, const uint8_t *src, size_t size); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/houdini_href_e.c b/cmark/houdini_href_e.c new file mode 100644 --- /dev/null +++ b/cmark/houdini_href_e.c @@ -0,0 +1,107 @@ +#include +#include +#include + +#include "houdini.h" + +/* + * The following characters will not be escaped: + * + * -_.+!*'(),%#@?=;:/,+&$ alphanum + * + * Note that this character set is the addition of: + * + * - The characters which are safe to be in an URL + * - The characters which are *not* safe to be in + * an URL because they are RESERVED characters. + * + * We asume (lazily) that any RESERVED char that + * appears inside an URL is actually meant to + * have its native function (i.e. as an URL + * component/separator) and hence needs no escaping. + * + * There are two exceptions: the chacters & (amp) + * and ' (single quote) do not appear in the table. + * They are meant to appear in the URL as components, + * yet they require special HTML-entity escaping + * to generate valid HTML markup. + * + * All other characters will be escaped to %XX. + * + */ +static const char HREF_SAFE[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +int +houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + static const uint8_t hex_chars[] = "0123456789ABCDEF"; + size_t i = 0, org; + uint8_t hex_str[3]; + + hex_str[0] = '%'; + + while (i < size) { + org = i; + while (i < size && HREF_SAFE[src[i]] != 0) + i++; + + if (likely(i > org)) + cmark_strbuf_put(ob, src + org, i - org); + + /* escaping */ + if (i >= size) + break; + + switch (src[i]) { + /* amp appears all the time in URLs, but needs + * HTML-entity escaping to be inside an href */ + case '&': + cmark_strbuf_puts(ob, "&"); + break; + + /* the single quote is a valid URL character + * according to the standard; it needs HTML + * entity escaping too */ + case '\'': + cmark_strbuf_puts(ob, "'"); + break; + + /* the space can be escaped to %20 or a plus + * sign. we're going with the generic escape + * for now. the plus thing is more commonly seen + * when building GET strings */ +#if 0 + case ' ': + cmark_strbuf_putc(ob, '+'); + break; +#endif + + /* every other character goes with a %XX escaping */ + default: + hex_str[1] = hex_chars[(src[i] >> 4) & 0xF]; + hex_str[2] = hex_chars[src[i] & 0xF]; + cmark_strbuf_put(ob, hex_str, 3); + } + + i++; + } + + return 1; +} diff --git a/cmark/houdini_html_e.c b/cmark/houdini_html_e.c new file mode 100644 --- /dev/null +++ b/cmark/houdini_html_e.c @@ -0,0 +1,81 @@ +#include +#include +#include + +#include "houdini.h" + +/** + * According to the OWASP rules: + * + * & --> & + * < --> < + * > --> > + * " --> " + * ' --> ' ' is not recommended + * / --> / forward slash is included as it helps end an HTML entity + * + */ +static const char HTML_ESCAPE_TABLE[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static const char *HTML_ESCAPES[] = { + "", + """, + "&", + "'", + "/", + "<", + ">" +}; + +int +houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure) +{ + size_t i = 0, org, esc = 0; + + while (i < size) { + org = i; + while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0) + i++; + + if (i > org) + cmark_strbuf_put(ob, src + org, i - org); + + /* escaping */ + if (unlikely(i >= size)) + break; + + /* The forward slash is only escaped in secure mode */ + if ((src[i] == '/' || src[i] == '\'') && !secure) { + cmark_strbuf_putc(ob, src[i]); + } else { + cmark_strbuf_puts(ob, HTML_ESCAPES[esc]); + } + + i++; + } + + return 1; +} + +int +houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + return houdini_escape_html0(ob, src, size, 1); +} diff --git a/cmark/houdini_html_u.c b/cmark/houdini_html_u.c new file mode 100644 --- /dev/null +++ b/cmark/houdini_html_u.c @@ -0,0 +1,116 @@ +#include +#include +#include + +#include "buffer.h" +#include "houdini.h" +#include "utf8.h" +#include "html_unescape.h" + +size_t +houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + size_t i = 0; + + if (size > 3 && src[0] == '#') { + int codepoint = 0; + + if (_isdigit(src[1])) { + for (i = 1; i < size && _isdigit(src[i]); ++i) { + int cp = (codepoint * 10) + (src[i] - '0'); + + if (cp < codepoint) + return 0; + + codepoint = cp; + } + } + + else if (src[1] == 'x' || src[1] == 'X') { + for (i = 2; i < size && _isxdigit(src[i]); ++i) { + int cp = (codepoint * 16) + ((src[i] | 32) % 39 - 9); + + if (cp < codepoint) + return 0; + + codepoint = cp; + } + } + + if (i < size && src[i] == ';' && codepoint) { + utf8proc_encode_char(codepoint, ob); + return i + 1; + } + } + + else { + if (size > MAX_WORD_LENGTH) + size = MAX_WORD_LENGTH; + + for (i = MIN_WORD_LENGTH; i < size; ++i) { + if (src[i] == ' ') + break; + + if (src[i] == ';') { + const struct html_ent *entity = find_entity((char *)src, i); + + if (entity != NULL) { + int len = 0; + while (len < 4 && entity->utf8[len] != '\0') { + ++len; + } + cmark_strbuf_put(ob, entity->utf8, len); + return i + 1; + } + + break; + } + } + } + + return 0; +} + +int +houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + size_t i = 0, org, ent; + + while (i < size) { + org = i; + while (i < size && src[i] != '&') + i++; + + if (likely(i > org)) { + if (unlikely(org == 0)) { + if (i >= size) + return 0; + + cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size)); + } + + cmark_strbuf_put(ob, src + org, i - org); + } + + /* escaping */ + if (i >= size) + break; + + i++; + + ent = houdini_unescape_ent(ob, src + i, size - i); + i += ent; + + /* not really an entity */ + if (ent == 0) + cmark_strbuf_putc(ob, '&'); + } + + return 1; +} + +void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size) +{ + if (!houdini_unescape_html(ob, src, size)) + cmark_strbuf_put(ob, src, size); +} diff --git a/cmark/html.c b/cmark/html.c new file mode 100644 --- /dev/null +++ b/cmark/html.c @@ -0,0 +1,322 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "houdini.h" + +// Functions to convert cmark_nodes to HTML strings. + +static void escape_html(cmark_strbuf *dest, const unsigned char *source, int length) +{ + if (length < 0) + length = strlen((char *)source); + + houdini_escape_html0(dest, source, (size_t)length, 0); +} + +static void escape_href(cmark_strbuf *dest, const unsigned char *source, int length) +{ + if (length < 0) + length = strlen((char *)source); + + houdini_escape_href(dest, source, (size_t)length); +} + +static inline void cr(cmark_strbuf *html) +{ + if (html->size && html->ptr[html->size - 1] != '\n') + cmark_strbuf_putc(html, '\n'); +} + +struct render_state { + cmark_strbuf* html; + cmark_node *plain; +}; + +static void +S_render_sourcepos(cmark_node *node, cmark_strbuf *html, int options) +{ + if (CMARK_OPT_SOURCEPOS & options) { + cmark_strbuf_printf(html, " data-sourcepos=\"%d:%d-%d:%d\"", + cmark_node_get_start_line(node), + cmark_node_get_start_column(node), + cmark_node_get_end_line(node), + cmark_node_get_end_column(node)); + } +} + +static int +S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state, int options) +{ + cmark_node *parent; + cmark_node *grandparent; + cmark_strbuf *html = state->html; + char start_header[] = "plain == node) { // back at original node + state->plain = NULL; + } + + if (state->plain != NULL) { + switch(node->type) { + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + case CMARK_NODE_INLINE_HTML: + escape_html(html, node->as.literal.data, + node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + case CMARK_NODE_SOFTBREAK: + cmark_strbuf_putc(html, ' '); + break; + + default: + break; + } + return 1; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + cr(html); + cmark_strbuf_puts(html, "\n"); + } else { + cr(html); + cmark_strbuf_puts(html, "\n"); + } + break; + + case CMARK_NODE_LIST: { + cmark_list_type list_type = node->as.list.list_type; + int start = node->as.list.start; + + if (entering) { + cr(html); + if (list_type == CMARK_BULLET_LIST) { + cmark_strbuf_puts(html, "\n"); + } else if (start == 1) { + cmark_strbuf_puts(html, "\n"); + } else { + cmark_strbuf_printf(html, + "
    \n"); + } + } else { + cmark_strbuf_puts(html, + list_type == CMARK_BULLET_LIST ? + "\n" : "
\n"); + } + break; + } + + case CMARK_NODE_ITEM: + if (entering) { + cr(html); + cmark_strbuf_puts(html, "'); + } else { + cmark_strbuf_puts(html, "\n"); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + cr(html); + start_header[2] = '0' + node->as.header.level; + cmark_strbuf_puts(html, start_header); + S_render_sourcepos(node, html, options); + cmark_strbuf_putc(html, '>'); + } else { + end_header[3] = '0' + node->as.header.level; + cmark_strbuf_puts(html, end_header); + cmark_strbuf_puts(html, ">\n"); + } + break; + + case CMARK_NODE_CODE_BLOCK: + cr(html); + + if (!node->as.code.fenced || node->as.code.info.len == 0) { + cmark_strbuf_puts(html, ""); + } else { + int first_tag = 0; + while (first_tag < node->as.code.info.len && + node->as.code.info.data[first_tag] != ' ') { + first_tag += 1; + } + + cmark_strbuf_puts(html, "as.code.info.data, first_tag); + cmark_strbuf_puts(html, "\">"); + } + + escape_html(html, node->as.code.literal.data, + node->as.code.literal.len); + cmark_strbuf_puts(html, "\n"); + break; + + case CMARK_NODE_HTML: + cr(html); + cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_HRULE: + cr(html); + cmark_strbuf_puts(html, "\n"); + break; + + case CMARK_NODE_PARAGRAPH: + parent = cmark_node_parent(node); + grandparent = cmark_node_parent(parent); + if (grandparent != NULL && + grandparent->type == CMARK_NODE_LIST) { + tight = grandparent->as.list.tight; + } else { + tight = false; + } + if (!tight) { + if (entering) { + cr(html); + cmark_strbuf_puts(html, "'); + } else { + cmark_strbuf_puts(html, "

\n"); + } + } + break; + + case CMARK_NODE_TEXT: + escape_html(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + cmark_strbuf_puts(html, "
\n"); + break; + + case CMARK_NODE_SOFTBREAK: + if (options & CMARK_OPT_HARDBREAKS) { + cmark_strbuf_puts(html, "
\n"); + } else { + cmark_strbuf_putc(html, '\n'); + } + break; + + case CMARK_NODE_CODE: + cmark_strbuf_puts(html, ""); + escape_html(html, node->as.literal.data, node->as.literal.len); + cmark_strbuf_puts(html, ""); + break; + + case CMARK_NODE_INLINE_HTML: + cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len); + break; + + case CMARK_NODE_STRONG: + if (entering) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + cmark_strbuf_puts(html, ""); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_LINK: + if (entering) { + cmark_strbuf_puts(html, "as.link.url) + escape_href(html, node->as.link.url, -1); + + if (node->as.link.title) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title, -1); + } + + cmark_strbuf_puts(html, "\">"); + } else { + cmark_strbuf_puts(html, ""); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + cmark_strbuf_puts(html, "as.link.url) + escape_href(html, node->as.link.url, -1); + + cmark_strbuf_puts(html, "\" alt=\""); + state->plain = node; + } else { + if (node->as.link.title) { + cmark_strbuf_puts(html, "\" title=\""); + escape_html(html, node->as.link.title, -1); + } + + cmark_strbuf_puts(html, "\" />"); + } + break; + + default: + assert(false); + break; + } + + // cmark_strbuf_putc(html, 'x'); + return 1; +} + +char *cmark_render_html(cmark_node *root, int options) +{ + char *result; + cmark_strbuf html = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = { &html, NULL }; + cmark_iter *iter = cmark_iter_new(root); + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state, options); + } + result = (char *)cmark_strbuf_detach(&html); + + cmark_iter_free(iter); + return result; +} diff --git a/cmark/html_unescape.h b/cmark/html_unescape.h new file mode 100644 --- /dev/null +++ b/cmark/html_unescape.h @@ -0,0 +1,13375 @@ +/* ANSI-C code produced by gperf version 3.0.3 */ +/* Command-line: /Library/Developer/CommandLineTools/usr/bin/gperf -L ANSI-C -I -t -N find_entity -H hash_entity -K entity -C -l -F ',{0}' --null-strings -m5 -P -Q entity_pool src/html_unescape.gperf */ +/* Computed positions: -k'1-7,10,12,$' */ + +#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \ + && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \ + && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \ + && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \ + && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \ + && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \ + && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \ + && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \ + && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \ + && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \ + && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \ + && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \ + && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \ + && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \ + && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \ + && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \ + && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \ + && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \ + && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \ + && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \ + && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \ + && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \ + && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)) +/* The character set is not based on ISO-646. */ +#error "gperf generated tables don't work with this execution character set. Please report a bug to ." +#endif + +#line 1 "src/html_unescape.gperf" +struct html_ent { + int entity; + unsigned char utf8[4]; +}; +#include +#include + +#define TOTAL_KEYWORDS 2125 +#define MIN_WORD_LENGTH 2 +#define MAX_WORD_LENGTH 31 +#define MIN_HASH_VALUE 39 +#define MAX_HASH_VALUE 16000 +/* maximum key range = 15962, duplicates = 0 */ + +#ifdef __GNUC__ +__inline +#else +#ifdef __cplusplus +inline +#endif +#endif +static unsigned int +hash_entity (register const char *str, register unsigned int len) +{ + static const unsigned short asso_values[] = + { + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 2, + 3, 7, 2, 4, 8, 16001, 10, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 1890, 1538, 220, 165, 1045, + 535, 1971, 1187, 1262, 35, 126, 201, 133, 350, 1487, + 1965, 3, 478, 134, 8, 147, 73, 41, 23, 212, + 9, 16001, 2, 16001, 2, 16001, 16001, 4154, 29, 3168, + 429, 10, 146, 1925, 2307, 280, 1313, 1924, 4, 651, + 27, 1031, 65, 176, 2, 6, 17, 15, 107, 482, + 3207, 3865, 757, 131, 178, 4, 4, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, + 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001, 16001 + }; + register unsigned int hval = len; + + switch (hval) + { + default: + hval += asso_values[(unsigned char)str[11]]; + /*FALLTHROUGH*/ + case 11: + case 10: + hval += asso_values[(unsigned char)str[9]]; + /*FALLTHROUGH*/ + case 9: + case 8: + case 7: + hval += asso_values[(unsigned char)str[6]]; + /*FALLTHROUGH*/ + case 6: + hval += asso_values[(unsigned char)str[5]]; + /*FALLTHROUGH*/ + case 5: + hval += asso_values[(unsigned char)str[4]+1]; + /*FALLTHROUGH*/ + case 4: + hval += asso_values[(unsigned char)str[3]+3]; + /*FALLTHROUGH*/ + case 3: + hval += asso_values[(unsigned char)str[2]+1]; + /*FALLTHROUGH*/ + case 2: + hval += asso_values[(unsigned char)str[1]+4]; + /*FALLTHROUGH*/ + case 1: + hval += asso_values[(unsigned char)str[0]]; + break; + } + return hval + asso_values[(unsigned char)str[len - 1]]; +} + +struct entity_pool_t + { + char entity_pool_str39[sizeof("rarr")]; + char entity_pool_str41[sizeof("larr")]; + char entity_pool_str49[sizeof("lat")]; + char entity_pool_str52[sizeof("uarr")]; + char entity_pool_str55[sizeof("npr")]; + char entity_pool_str62[sizeof("rarrtl")]; + char entity_pool_str64[sizeof("larrtl")]; + char entity_pool_str65[sizeof("roarr")]; + char entity_pool_str67[sizeof("loarr")]; + char entity_pool_str68[sizeof("not")]; + char entity_pool_str69[sizeof("rpar")]; + char entity_pool_str70[sizeof("bot")]; + char entity_pool_str71[sizeof("lpar")]; + char entity_pool_str73[sizeof("spar")]; + char entity_pool_str75[sizeof("ll")]; + char entity_pool_str76[sizeof("uharr")]; + char entity_pool_str77[sizeof("epar")]; + char entity_pool_str81[sizeof("el")]; + char entity_pool_str83[sizeof("rotimes")]; + char entity_pool_str85[sizeof("lotimes")]; + char entity_pool_str86[sizeof("par")]; + char entity_pool_str88[sizeof("nharr")]; + char entity_pool_str94[sizeof("npar")]; + char entity_pool_str97[sizeof("tprime")]; + char entity_pool_str101[sizeof("els")]; + char entity_pool_str102[sizeof("eparsl")]; + char entity_pool_str104[sizeof("ensp")]; + char entity_pool_str109[sizeof("bprime")]; + char entity_pool_str110[sizeof("lnap")]; + char entity_pool_str111[sizeof("blk14")]; + char entity_pool_str115[sizeof("blk12")]; + char entity_pool_str117[sizeof("blk34")]; + char entity_pool_str119[sizeof("nparsl")]; + char entity_pool_str123[sizeof("nldr")]; + char entity_pool_str124[sizeof("rlarr")]; + char entity_pool_str125[sizeof("npart")]; + char entity_pool_str126[sizeof("llarr")]; + char entity_pool_str127[sizeof("nlt")]; + char entity_pool_str128[sizeof("slarr")]; + char entity_pool_str138[sizeof("nparallel")]; + char entity_pool_str143[sizeof("Tau")]; + char entity_pool_str144[sizeof("varr")]; + char entity_pool_str146[sizeof("squ")]; + char entity_pool_str149[sizeof("nlarr")]; + char entity_pool_str152[sizeof("tau")]; + char entity_pool_str165[sizeof("lne")]; + char entity_pool_str166[sizeof("rrarr")]; + char entity_pool_str168[sizeof("lrarr")]; + char entity_pool_str170[sizeof("srarr")]; + char entity_pool_str171[sizeof("rharul")]; + char entity_pool_str173[sizeof("lharul")]; + char entity_pool_str174[sizeof("erarr")]; + char entity_pool_str176[sizeof("pr")]; + char entity_pool_str177[sizeof("rharu")]; + char entity_pool_str179[sizeof("lharu")]; + char entity_pool_str184[sizeof("Uarr")]; + char entity_pool_str188[sizeof("nGt")]; + char entity_pool_str190[sizeof("bne")]; + char entity_pool_str191[sizeof("nrarr")]; + char entity_pool_str194[sizeof("swarr")]; + char entity_pool_str198[sizeof("rarrap")]; + char entity_pool_str200[sizeof("upuparrows")]; + char entity_pool_str202[sizeof("Darr")]; + char entity_pool_str205[sizeof("rbarr")]; + char entity_pool_str206[sizeof("Dot")]; + char entity_pool_str207[sizeof("lbarr")]; + char entity_pool_str215[sizeof("nwarr")]; + char entity_pool_str217[sizeof("smt")]; + char entity_pool_str222[sizeof("emsp14")]; + char entity_pool_str223[sizeof("rarrpl")]; + char entity_pool_str225[sizeof("larrpl")]; + char entity_pool_str230[sizeof("phmmat")]; + char entity_pool_str232[sizeof("emsp13")]; + char entity_pool_str234[sizeof("LT")]; + char entity_pool_str238[sizeof("Larr")]; + char entity_pool_str239[sizeof("rbrkslu")]; + char entity_pool_str241[sizeof("lbrkslu")]; + char entity_pool_str243[sizeof("napos")]; + char entity_pool_str251[sizeof("nle")]; + char entity_pool_str253[sizeof("rHar")]; + char entity_pool_str255[sizeof("lHar")]; + char entity_pool_str256[sizeof("qprime")]; + char entity_pool_str258[sizeof("lap")]; + char entity_pool_str265[sizeof("nbsp")]; + char entity_pool_str266[sizeof("uHar")]; + char entity_pool_str267[sizeof("top")]; + char entity_pool_str269[sizeof("Vbar")]; + char entity_pool_str272[sizeof("Ll")]; + char entity_pool_str276[sizeof("prap")]; + char entity_pool_str278[sizeof("emsp")]; + char entity_pool_str281[sizeof("nap")]; + char entity_pool_str294[sizeof("looparrowleft")]; + char entity_pool_str296[sizeof("le")]; + char entity_pool_str300[sizeof("sharp")]; + char entity_pool_str302[sizeof("ee")]; + char entity_pool_str310[sizeof("les")]; + char entity_pool_str311[sizeof("in")]; + char entity_pool_str312[sizeof("prop")]; + char entity_pool_str314[sizeof("topbot")]; + char entity_pool_str317[sizeof("int")]; + char entity_pool_str319[sizeof("ne")]; + char entity_pool_str329[sizeof("nprcue")]; + char entity_pool_str331[sizeof("pre")]; + char entity_pool_str332[sizeof("epsi")]; + char entity_pool_str337[sizeof("upsi")]; + char entity_pool_str338[sizeof("there4")]; + char entity_pool_str342[sizeof("rbrke")]; + char entity_pool_str343[sizeof("searr")]; + char entity_pool_str344[sizeof("lbrke")]; + char entity_pool_str346[sizeof("blacktriangle")]; + char entity_pool_str349[sizeof("lneq")]; + char entity_pool_str352[sizeof("lneqq")]; + char entity_pool_str354[sizeof("plus")]; + char entity_pool_str355[sizeof("nles")]; + char entity_pool_str356[sizeof("nedot")]; + char entity_pool_str357[sizeof("blacktriangleleft")]; + char entity_pool_str358[sizeof("blacktriangleright")]; + char entity_pool_str364[sizeof("nearr")]; + char entity_pool_str367[sizeof("blacktriangledown")]; + char entity_pool_str373[sizeof("nless")]; + char entity_pool_str374[sizeof("emacr")]; + char entity_pool_str378[sizeof("vprop")]; + char entity_pool_str379[sizeof("umacr")]; + char entity_pool_str383[sizeof("smeparsl")]; + char entity_pool_str387[sizeof("Map")]; + char entity_pool_str390[sizeof("plusdu")]; + char entity_pool_str391[sizeof("Not")]; + char entity_pool_str408[sizeof("Verbar")]; + char entity_pool_str426[sizeof("perp")]; + char entity_pool_str430[sizeof("fltns")]; + char entity_pool_str431[sizeof("plusmn")]; + char entity_pool_str435[sizeof("nleq")]; + char entity_pool_str438[sizeof("nleqq")]; + char entity_pool_str440[sizeof("frac34")]; + char entity_pool_str441[sizeof("frac14")]; + char entity_pool_str442[sizeof("verbar")]; + char entity_pool_str443[sizeof("frac12")]; + char entity_pool_str444[sizeof("frac35")]; + char entity_pool_str445[sizeof("frac15")]; + char entity_pool_str446[sizeof("frac45")]; + char entity_pool_str449[sizeof("frac25")]; + char entity_pool_str451[sizeof("frac13")]; + char entity_pool_str453[sizeof("frac16")]; + char entity_pool_str454[sizeof("prurel")]; + char entity_pool_str455[sizeof("frac23")]; + char entity_pool_str456[sizeof("frac38")]; + char entity_pool_str457[sizeof("frac18")]; + char entity_pool_str458[sizeof("frac56")]; + char entity_pool_str462[sizeof("frac58")]; + char entity_pool_str464[sizeof("frac78")]; + char entity_pool_str465[sizeof("leq")]; + char entity_pool_str466[sizeof("darr")]; + char entity_pool_str469[sizeof("Upsi")]; + char entity_pool_str470[sizeof("dot")]; + char entity_pool_str471[sizeof("phone")]; + char entity_pool_str474[sizeof("Cap")]; + char entity_pool_str478[sizeof("blacksquare")]; + char entity_pool_str479[sizeof("rnmid")]; + char entity_pool_str483[sizeof("leqq")]; + char entity_pool_str486[sizeof("intcal")]; + char entity_pool_str490[sizeof("dharr")]; + char entity_pool_str494[sizeof("rhard")]; + char entity_pool_str496[sizeof("lhard")]; + char entity_pool_str505[sizeof("pluse")]; + char entity_pool_str511[sizeof("Umacr")]; + char entity_pool_str512[sizeof("Vee")]; + char entity_pool_str515[sizeof("Rarr")]; + char entity_pool_str527[sizeof("Cross")]; + char entity_pool_str529[sizeof("rsqb")]; + char entity_pool_str531[sizeof("lsqb")]; + char entity_pool_str538[sizeof("Rarrtl")]; + char entity_pool_str541[sizeof("esdot")]; + char entity_pool_str546[sizeof("vee")]; + char entity_pool_str547[sizeof("nbumpe")]; + char entity_pool_str553[sizeof("llcorner")]; + char entity_pool_str554[sizeof("fpartint")]; + char entity_pool_str558[sizeof("squf")]; + char entity_pool_str559[sizeof("plankv")]; + char entity_pool_str562[sizeof("eqvparsl")]; + char entity_pool_str564[sizeof("ulcorner")]; + char entity_pool_str566[sizeof("wp")]; + char entity_pool_str571[sizeof("lozf")]; + char entity_pool_str575[sizeof("COPY")]; + char entity_pool_str577[sizeof("ulcorn")]; + char entity_pool_str582[sizeof("veebar")]; + char entity_pool_str584[sizeof("part")]; + char entity_pool_str589[sizeof("square")]; + char entity_pool_str591[sizeof("nbump")]; + char entity_pool_str592[sizeof("bernou")]; + char entity_pool_str593[sizeof("wr")]; + char entity_pool_str594[sizeof("rBarr")]; + char entity_pool_str595[sizeof("lrcorner")]; + char entity_pool_str596[sizeof("lBarr")]; + char entity_pool_str599[sizeof("bnot")]; + char entity_pool_str601[sizeof("semi")]; + char entity_pool_str606[sizeof("urcorner")]; + char entity_pool_str612[sizeof("NotSubset")]; + char entity_pool_str614[sizeof("ropf")]; + char entity_pool_str615[sizeof("Qopf")]; + char entity_pool_str616[sizeof("lopf")]; + char entity_pool_str618[sizeof("sopf")]; + char entity_pool_str619[sizeof("urcorn")]; + char entity_pool_str620[sizeof("Topf")]; + char entity_pool_str621[sizeof("Zopf")]; + char entity_pool_str622[sizeof("eopf")]; + char entity_pool_str626[sizeof("ropar")]; + char entity_pool_str627[sizeof("uopf")]; + char entity_pool_str628[sizeof("lopar")]; + char entity_pool_str629[sizeof("topf")]; + char entity_pool_str635[sizeof("Xopf")]; + char entity_pool_str639[sizeof("nopf")]; + char entity_pool_str641[sizeof("bopf")]; + char entity_pool_str642[sizeof("epsiv")]; + char entity_pool_str643[sizeof("fnof")]; + char entity_pool_str644[sizeof("imacr")]; + char entity_pool_str647[sizeof("Jopf")]; + char entity_pool_str649[sizeof("nhpar")]; + char entity_pool_str653[sizeof("Wopf")]; + char entity_pool_str658[sizeof("Sqrt")]; + char entity_pool_str659[sizeof("nsub")]; + char entity_pool_str661[sizeof("napid")]; + char entity_pool_str664[sizeof("NotSuperset")]; + char entity_pool_str667[sizeof("brvbar")]; + char entity_pool_str670[sizeof("sol")]; + char entity_pool_str675[sizeof("easter")]; + char entity_pool_str677[sizeof("popf")]; + char entity_pool_str680[sizeof("dHar")]; + char entity_pool_str685[sizeof("Vopf")]; + char entity_pool_str690[sizeof("nsupset")]; + char entity_pool_str691[sizeof("nsup")]; + char entity_pool_str692[sizeof("vBar")]; + char entity_pool_str694[sizeof("nsubset")]; + char entity_pool_str700[sizeof("thkap")]; + char entity_pool_str704[sizeof("nis")]; + char entity_pool_str705[sizeof("profsurf")]; + char entity_pool_str706[sizeof("solb")]; + char entity_pool_str710[sizeof("lnsim")]; + char entity_pool_str712[sizeof("solbar")]; + char entity_pool_str717[sizeof("Square")]; + char entity_pool_str719[sizeof("vopf")]; + char entity_pool_str723[sizeof("uharl")]; + char entity_pool_str725[sizeof("ulcrop")]; + char entity_pool_str729[sizeof("eqsim")]; + char entity_pool_str730[sizeof("equiv")]; + char entity_pool_str733[sizeof("ell")]; + char entity_pool_str734[sizeof("smashp")]; + char entity_pool_str735[sizeof("mp")]; + char entity_pool_str738[sizeof("Kopf")]; + char entity_pool_str741[sizeof("simrarr")]; + char entity_pool_str743[sizeof("flat")]; + char entity_pool_str745[sizeof("Mopf")]; + char entity_pool_str746[sizeof("Sopf")]; + char entity_pool_str747[sizeof("mldr")]; + char entity_pool_str748[sizeof("rlm")]; + char entity_pool_str749[sizeof("iprod")]; + char entity_pool_str756[sizeof("lparlt")]; + char entity_pool_str758[sizeof("fopf")]; + char entity_pool_str759[sizeof("Uopf")]; + char entity_pool_str763[sizeof("varsubsetneq")]; + char entity_pool_str764[sizeof("varsubsetneqq")]; + char entity_pool_str767[sizeof("urcrop")]; + char entity_pool_str768[sizeof("LessLess")]; + char entity_pool_str770[sizeof("Re")]; + char entity_pool_str773[sizeof("NotNestedLessLess")]; + char entity_pool_str777[sizeof("Dopf")]; + char entity_pool_str779[sizeof("forkv")]; + char entity_pool_str781[sizeof("nsqsube")]; + char entity_pool_str783[sizeof("nsupe")]; + char entity_pool_str787[sizeof("nsube")]; + char entity_pool_str788[sizeof("qopf")]; + char entity_pool_str789[sizeof("rlhar")]; + char entity_pool_str792[sizeof("lrm")]; + char entity_pool_str796[sizeof("nlsim")]; + char entity_pool_str798[sizeof("pound")]; + char entity_pool_str799[sizeof("varsupsetneq")]; + char entity_pool_str800[sizeof("varsupsetneqq")]; + char entity_pool_str802[sizeof("bnequiv")]; + char entity_pool_str813[sizeof("Lopf")]; + char entity_pool_str817[sizeof("nsqsupe")]; + char entity_pool_str820[sizeof("rarrlp")]; + char entity_pool_str821[sizeof("wedbar")]; + char entity_pool_str822[sizeof("larrlp")]; + char entity_pool_str824[sizeof("Yopf")]; + char entity_pool_str829[sizeof("NotReverseElement")]; + char entity_pool_str832[sizeof("Copf")]; + char entity_pool_str833[sizeof("lrhar")]; + char entity_pool_str848[sizeof("parsl")]; + char entity_pool_str849[sizeof("uml")]; + char entity_pool_str850[sizeof("marker")]; + char entity_pool_str851[sizeof("nsupseteq")]; + char entity_pool_str855[sizeof("nsubseteq")]; + char entity_pool_str861[sizeof("squarf")]; + char entity_pool_str862[sizeof("Vert")]; + char entity_pool_str874[sizeof("SquareSupersetEqual")]; + char entity_pool_str876[sizeof("prsim")]; + char entity_pool_str879[sizeof("SquareSubsetEqual")]; + char entity_pool_str882[sizeof("SquareSuperset")]; + char entity_pool_str887[sizeof("SquareSubset")]; + char entity_pool_str888[sizeof("nvap")]; + char entity_pool_str892[sizeof("iopf")]; + char entity_pool_str894[sizeof("pm")]; + char entity_pool_str896[sizeof("vert")]; + char entity_pool_str898[sizeof("thetav")]; + char entity_pool_str901[sizeof("loz")]; + char entity_pool_str905[sizeof("map")]; + char entity_pool_str920[sizeof("lesseqqgtr")]; + char entity_pool_str934[sizeof("rscr")]; + char entity_pool_str935[sizeof("Qscr")]; + char entity_pool_str936[sizeof("lscr")]; + char entity_pool_str938[sizeof("sscr")]; + char entity_pool_str940[sizeof("Tscr")]; + char entity_pool_str941[sizeof("Zscr")]; + char entity_pool_str942[sizeof("escr")]; + char entity_pool_str947[sizeof("uscr")]; + char entity_pool_str949[sizeof("tscr")]; + char entity_pool_str951[sizeof("imof")]; + char entity_pool_str952[sizeof("Coproduct")]; + char entity_pool_str955[sizeof("Xscr")]; + char entity_pool_str956[sizeof("Xi")]; + char entity_pool_str959[sizeof("nscr")]; + char entity_pool_str960[sizeof("ni")]; + char entity_pool_str961[sizeof("bscr")]; + char entity_pool_str962[sizeof("Nopf")]; + char entity_pool_str967[sizeof("Jscr")]; + char entity_pool_str968[sizeof("preceq")]; + char entity_pool_str971[sizeof("nvrArr")]; + char entity_pool_str972[sizeof("backprime")]; + char entity_pool_str973[sizeof("Wscr")]; + char entity_pool_str975[sizeof("varphi")]; + char entity_pool_str984[sizeof("nsmid")]; + char entity_pool_str991[sizeof("dlcorn")]; + char entity_pool_str997[sizeof("pscr")]; + char entity_pool_str998[sizeof("pi")]; + char entity_pool_str1005[sizeof("Vscr")]; + char entity_pool_str1011[sizeof("nesim")]; + char entity_pool_str1021[sizeof("simne")]; + char entity_pool_str1028[sizeof("nsupseteqq")]; + char entity_pool_str1032[sizeof("nsubseteqq")]; + char entity_pool_str1033[sizeof("drcorn")]; + char entity_pool_str1038[sizeof("rbrace")]; + char entity_pool_str1039[sizeof("vscr")]; + char entity_pool_str1040[sizeof("lbrace")]; + char entity_pool_str1041[sizeof("dopf")]; + char entity_pool_str1049[sizeof("frasl")]; + char entity_pool_str1055[sizeof("LessTilde")]; + char entity_pool_str1058[sizeof("Kscr")]; + char entity_pool_str1064[sizeof("pluscir")]; + char entity_pool_str1065[sizeof("Mscr")]; + char entity_pool_str1066[sizeof("Sscr")]; + char entity_pool_str1067[sizeof("rbrksld")]; + char entity_pool_str1069[sizeof("lbrksld")]; + char entity_pool_str1070[sizeof("RBarr")]; + char entity_pool_str1073[sizeof("sqcaps")]; + char entity_pool_str1074[sizeof("rArr")]; + char entity_pool_str1075[sizeof("bNot")]; + char entity_pool_str1076[sizeof("lArr")]; + char entity_pool_str1078[sizeof("fscr")]; + char entity_pool_str1079[sizeof("Uscr")]; + char entity_pool_str1087[sizeof("uArr")]; + char entity_pool_str1090[sizeof("Ropf")]; + char entity_pool_str1094[sizeof("wopf")]; + char entity_pool_str1097[sizeof("Dscr")]; + char entity_pool_str1098[sizeof("opar")]; + char entity_pool_str1099[sizeof("seswar")]; + char entity_pool_str1103[sizeof("Del")]; + char entity_pool_str1104[sizeof("rAarr")]; + char entity_pool_str1105[sizeof("rho")]; + char entity_pool_str1106[sizeof("lAarr")]; + char entity_pool_str1107[sizeof("preccurlyeq")]; + char entity_pool_str1108[sizeof("qscr")]; + char entity_pool_str1111[sizeof("macr")]; + char entity_pool_str1115[sizeof("notin")]; + char entity_pool_str1120[sizeof("equivDD")]; + char entity_pool_str1125[sizeof("sqcap")]; + char entity_pool_str1127[sizeof("nspar")]; + char entity_pool_str1131[sizeof("olt")]; + char entity_pool_str1132[sizeof("ratio")]; + char entity_pool_str1133[sizeof("Lscr")]; + char entity_pool_str1137[sizeof("dharl")]; + char entity_pool_str1139[sizeof("dlcrop")]; + char entity_pool_str1140[sizeof("DoubleDot")]; + char entity_pool_str1141[sizeof("dotplus")]; + char entity_pool_str1142[sizeof("or")]; + char entity_pool_str1144[sizeof("Yscr")]; + char entity_pool_str1147[sizeof("Fopf")]; + char entity_pool_str1152[sizeof("Cscr")]; + char entity_pool_str1153[sizeof("olarr")]; + char entity_pool_str1154[sizeof("nrarrw")]; + char entity_pool_str1159[sizeof("lvertneqq")]; + char entity_pool_str1160[sizeof("eqslantgtr")]; + char entity_pool_str1164[sizeof("thorn")]; + char entity_pool_str1169[sizeof("eqslantless")]; + char entity_pool_str1172[sizeof("incare")]; + char entity_pool_str1179[sizeof("vArr")]; + char entity_pool_str1180[sizeof("rppolint")]; + char entity_pool_str1181[sizeof("drcrop")]; + char entity_pool_str1187[sizeof("parallel")]; + char entity_pool_str1195[sizeof("orarr")]; + char entity_pool_str1196[sizeof("ssmile")]; + char entity_pool_str1200[sizeof("DoubleLeftTee")]; + char entity_pool_str1201[sizeof("erDot")]; + char entity_pool_str1202[sizeof("diams")]; + char entity_pool_str1203[sizeof("ssetmn")]; + char entity_pool_str1208[sizeof("oS")]; + char entity_pool_str1212[sizeof("iscr")]; + char entity_pool_str1213[sizeof("ii")]; + char entity_pool_str1214[sizeof("rect")]; + char entity_pool_str1217[sizeof("nsccue")]; + char entity_pool_str1218[sizeof("sect")]; + char entity_pool_str1220[sizeof("mlcp")]; + char entity_pool_str1224[sizeof("oror")]; + char entity_pool_str1226[sizeof("DoubleContourIntegral")]; + char entity_pool_str1230[sizeof("equals")]; + char entity_pool_str1232[sizeof("Hat")]; + char entity_pool_str1236[sizeof("sstarf")]; + char entity_pool_str1237[sizeof("mstpos")]; + char entity_pool_str1239[sizeof("die")]; + char entity_pool_str1240[sizeof("measuredangle")]; + char entity_pool_str1252[sizeof("forall")]; + char entity_pool_str1255[sizeof("notinvb")]; + char entity_pool_str1263[sizeof("mopf")]; + char entity_pool_str1270[sizeof("niv")]; + char entity_pool_str1280[sizeof("vBarv")]; + char entity_pool_str1282[sizeof("Nscr")]; + char entity_pool_str1284[sizeof("period")]; + char entity_pool_str1292[sizeof("becaus")]; + char entity_pool_str1298[sizeof("between")]; + char entity_pool_str1299[sizeof("Int")]; + char entity_pool_str1307[sizeof("because")]; + char entity_pool_str1308[sizeof("piv")]; + char entity_pool_str1326[sizeof("rfr")]; + char entity_pool_str1327[sizeof("Qfr")]; + char entity_pool_str1328[sizeof("lfr")]; + char entity_pool_str1330[sizeof("sfr")]; + char entity_pool_str1331[sizeof("nleftrightarrow")]; + char entity_pool_str1332[sizeof("Tfr")]; + char entity_pool_str1333[sizeof("Zfr")]; + char entity_pool_str1334[sizeof("efr")]; + char entity_pool_str1338[sizeof("sim")]; + char entity_pool_str1339[sizeof("ufr")]; + char entity_pool_str1340[sizeof("roplus")]; + char entity_pool_str1341[sizeof("tfr")]; + char entity_pool_str1342[sizeof("loplus")]; + char entity_pool_str1347[sizeof("Xfr")]; + char entity_pool_str1350[sizeof("real")]; + char entity_pool_str1351[sizeof("nfr")]; + char entity_pool_str1353[sizeof("bfr")]; + char entity_pool_str1355[sizeof("NotHumpEqual")]; + char entity_pool_str1359[sizeof("Jfr")]; + char entity_pool_str1361[sizeof("dscr")]; + char entity_pool_str1365[sizeof("Wfr")]; + char entity_pool_str1367[sizeof("blacklozenge")]; + char entity_pool_str1369[sizeof("zopf")]; + char entity_pool_str1370[sizeof("reals")]; + char entity_pool_str1372[sizeof("NotCupCap")]; + char entity_pool_str1375[sizeof("simplus")]; + char entity_pool_str1377[sizeof("ForAll")]; + char entity_pool_str1389[sizeof("pfr")]; + char entity_pool_str1395[sizeof("omacr")]; + char entity_pool_str1397[sizeof("Vfr")]; + char entity_pool_str1409[sizeof("Emacr")]; + char entity_pool_str1410[sizeof("Rscr")]; + char entity_pool_str1414[sizeof("wscr")]; + char entity_pool_str1423[sizeof("ShortUpArrow")]; + char entity_pool_str1429[sizeof("setmn")]; + char entity_pool_str1431[sizeof("vfr")]; + char entity_pool_str1450[sizeof("Kfr")]; + char entity_pool_str1455[sizeof("operp")]; + char entity_pool_str1457[sizeof("Mfr")]; + char entity_pool_str1458[sizeof("Sfr")]; + char entity_pool_str1461[sizeof("nltrie")]; + char entity_pool_str1467[sizeof("Fscr")]; + char entity_pool_str1470[sizeof("ffr")]; + char entity_pool_str1471[sizeof("Ufr")]; + char entity_pool_str1473[sizeof("shortmid")]; + char entity_pool_str1488[sizeof("nvsim")]; + char entity_pool_str1489[sizeof("Dfr")]; + char entity_pool_str1490[sizeof("lessdot")]; + char entity_pool_str1493[sizeof("profline")]; + char entity_pool_str1500[sizeof("qfr")]; + char entity_pool_str1501[sizeof("dArr")]; + char entity_pool_str1503[sizeof("nrtrie")]; + char entity_pool_str1507[sizeof("ShortRightArrow")]; + char entity_pool_str1515[sizeof("Therefore")]; + char entity_pool_str1519[sizeof("DD")]; + char entity_pool_str1524[sizeof("therefore")]; + char entity_pool_str1525[sizeof("Lfr")]; + char entity_pool_str1532[sizeof("target")]; + char entity_pool_str1535[sizeof("Element")]; + char entity_pool_str1536[sizeof("Yfr")]; + char entity_pool_str1537[sizeof("ClockwiseContourIntegral")]; + char entity_pool_str1542[sizeof("olcir")]; + char entity_pool_str1544[sizeof("Cfr")]; + char entity_pool_str1559[sizeof("female")]; + char entity_pool_str1560[sizeof("nsucceq")]; + char entity_pool_str1561[sizeof("oast")]; + char entity_pool_str1568[sizeof("percnt")]; + char entity_pool_str1578[sizeof("ordf")]; + char entity_pool_str1580[sizeof("ord")]; + char entity_pool_str1581[sizeof("Rho")]; + char entity_pool_str1583[sizeof("mscr")]; + char entity_pool_str1585[sizeof("nvrtrie")]; + char entity_pool_str1589[sizeof("lnE")]; + char entity_pool_str1597[sizeof("nhArr")]; + char entity_pool_str1598[sizeof("Or")]; + char entity_pool_str1602[sizeof("divide")]; + char entity_pool_str1604[sizeof("ifr")]; + char entity_pool_str1605[sizeof("elinters")]; + char entity_pool_str1615[sizeof("bsol")]; + char entity_pool_str1616[sizeof("nvlArr")]; + char entity_pool_str1626[sizeof("Imacr")]; + char entity_pool_str1628[sizeof("backsimeq")]; + char entity_pool_str1629[sizeof("twixt")]; + char entity_pool_str1630[sizeof("olcross")]; + char entity_pool_str1639[sizeof("rarrsim")]; + char entity_pool_str1640[sizeof("DoubleDownArrow")]; + char entity_pool_str1641[sizeof("larrsim")]; + char entity_pool_str1642[sizeof("emptyset")]; + char entity_pool_str1643[sizeof("oopf")]; + char entity_pool_str1645[sizeof("exist")]; + char entity_pool_str1648[sizeof("llhard")]; + char entity_pool_str1656[sizeof("excl")]; + char entity_pool_str1657[sizeof("Eopf")]; + char entity_pool_str1658[sizeof("nlArr")]; + char entity_pool_str1663[sizeof("thinsp")]; + char entity_pool_str1664[sizeof("NotSubsetEqual")]; + char entity_pool_str1665[sizeof("phi")]; + char entity_pool_str1666[sizeof("DoubleLeftArrow")]; + char entity_pool_str1668[sizeof("topcir")]; + char entity_pool_str1672[sizeof("div")]; + char entity_pool_str1674[sizeof("Nfr")]; + char entity_pool_str1675[sizeof("nlE")]; + char entity_pool_str1689[sizeof("zscr")]; + char entity_pool_str1690[sizeof("lrhard")]; + char entity_pool_str1697[sizeof("lltri")]; + char entity_pool_str1700[sizeof("nrArr")]; + char entity_pool_str1701[sizeof("NotSupersetEqual")]; + char entity_pool_str1703[sizeof("swArr")]; + char entity_pool_str1704[sizeof("ThickSpace")]; + char entity_pool_str1708[sizeof("ultri")]; + char entity_pool_str1709[sizeof("notnivb")]; + char entity_pool_str1711[sizeof("prime")]; + char entity_pool_str1714[sizeof("primes")]; + char entity_pool_str1716[sizeof("ohm")]; + char entity_pool_str1719[sizeof("CircleTimes")]; + char entity_pool_str1720[sizeof("nltri")]; + char entity_pool_str1723[sizeof("siml")]; + char entity_pool_str1724[sizeof("nwArr")]; + char entity_pool_str1727[sizeof("varpi")]; + char entity_pool_str1730[sizeof("orv")]; + char entity_pool_str1735[sizeof("setminus")]; + char entity_pool_str1739[sizeof("lrtri")]; + char entity_pool_str1743[sizeof("permil")]; + char entity_pool_str1744[sizeof("mid")]; + char entity_pool_str1750[sizeof("urtri")]; + char entity_pool_str1753[sizeof("dfr")]; + char entity_pool_str1754[sizeof("mho")]; + char entity_pool_str1755[sizeof("prE")]; + char entity_pool_str1759[sizeof("vsupne")]; + char entity_pool_str1762[sizeof("nrtri")]; + char entity_pool_str1763[sizeof("vsubne")]; + char entity_pool_str1765[sizeof("eDot")]; + char entity_pool_str1778[sizeof("lesges")]; + char entity_pool_str1781[sizeof("backepsilon")]; + char entity_pool_str1783[sizeof("ratail")]; + char entity_pool_str1785[sizeof("latail")]; + char entity_pool_str1788[sizeof("UpEquilibrium")]; + char entity_pool_str1791[sizeof("epsilon")]; + char entity_pool_str1796[sizeof("upsilon")]; + char entity_pool_str1798[sizeof("midast")]; + char entity_pool_str1799[sizeof("Hopf")]; + char entity_pool_str1800[sizeof("vltri")]; + char entity_pool_str1802[sizeof("Rfr")]; + char entity_pool_str1805[sizeof("Wedge")]; + char entity_pool_str1806[sizeof("wfr")]; + char entity_pool_str1812[sizeof("barwed")]; + char entity_pool_str1815[sizeof("malt")]; + char entity_pool_str1820[sizeof("Chi")]; + char entity_pool_str1821[sizeof("emptyv")]; + char entity_pool_str1822[sizeof("notni")]; + char entity_pool_str1827[sizeof("LessGreater")]; + char entity_pool_str1829[sizeof("diam")]; + char entity_pool_str1842[sizeof("vrtri")]; + char entity_pool_str1849[sizeof("CircleMinus")]; + char entity_pool_str1851[sizeof("Omacr")]; + char entity_pool_str1852[sizeof("seArr")]; + char entity_pool_str1859[sizeof("Ffr")]; + char entity_pool_str1865[sizeof("precneqq")]; + char entity_pool_str1867[sizeof("Diamond")]; + char entity_pool_str1868[sizeof("ordm")]; + char entity_pool_str1873[sizeof("neArr")]; + char entity_pool_str1874[sizeof("Iopf")]; + char entity_pool_str1875[sizeof("CircleDot")]; + char entity_pool_str1878[sizeof("prnap")]; + char entity_pool_str1884[sizeof("dotminus")]; + char entity_pool_str1903[sizeof("nshortmid")]; + char entity_pool_str1905[sizeof("bottom")]; + char entity_pool_str1907[sizeof("pointint")]; + char entity_pool_str1917[sizeof("SquareUnion")]; + char entity_pool_str1925[sizeof("jopf")]; + char entity_pool_str1928[sizeof("Upsilon")]; + char entity_pool_str1936[sizeof("Colone")]; + char entity_pool_str1938[sizeof("nvlt")]; + char entity_pool_str1941[sizeof("NestedLessLess")]; + char entity_pool_str1942[sizeof("Colon")]; + char entity_pool_str1945[sizeof("bsolhsub")]; + char entity_pool_str1949[sizeof("DoubleLeftRightArrow")]; + char entity_pool_str1950[sizeof("plussim")]; + char entity_pool_str1959[sizeof("image")]; + char entity_pool_str1960[sizeof("egs")]; + char entity_pool_str1963[sizeof("oscr")]; + char entity_pool_str1964[sizeof("swnwar")]; + char entity_pool_str1969[sizeof("zeetrf")]; + char entity_pool_str1973[sizeof("maltese")]; + char entity_pool_str1975[sizeof("mfr")]; + char entity_pool_str1976[sizeof("rarrfs")]; + char entity_pool_str1977[sizeof("Escr")]; + char entity_pool_str1978[sizeof("larrfs")]; + char entity_pool_str1985[sizeof("mnplus")]; + char entity_pool_str1986[sizeof("ngt")]; + char entity_pool_str1987[sizeof("ngtr")]; + char entity_pool_str1996[sizeof("gl")]; + char entity_pool_str2003[sizeof("diamondsuit")]; + char entity_pool_str2004[sizeof("GT")]; + char entity_pool_str2014[sizeof("lesssim")]; + char entity_pool_str2015[sizeof("dsol")]; + char entity_pool_str2023[sizeof("upharpoonleft")]; + char entity_pool_str2024[sizeof("SquareIntersection")]; + char entity_pool_str2025[sizeof("lsime")]; + char entity_pool_str2027[sizeof("nLt")]; + char entity_pool_str2029[sizeof("NotLess")]; + char entity_pool_str2031[sizeof("gnap")]; + char entity_pool_str2035[sizeof("scap")]; + char entity_pool_str2038[sizeof("mapstoleft")]; + char entity_pool_str2039[sizeof("NotLessLess")]; + char entity_pool_str2043[sizeof("rfloor")]; + char entity_pool_str2045[sizeof("lfloor")]; + char entity_pool_str2048[sizeof("nsime")]; + char entity_pool_str2050[sizeof("bsime")]; + char entity_pool_str2051[sizeof("NotLessEqual")]; + char entity_pool_str2052[sizeof("NotLessTilde")]; + char entity_pool_str2056[sizeof("ncap")]; + char entity_pool_str2059[sizeof("NotLessGreater")]; + char entity_pool_str2070[sizeof("precsim")]; + char entity_pool_str2072[sizeof("looparrowright")]; + char entity_pool_str2076[sizeof("Pr")]; + char entity_pool_str2077[sizeof("rcub")]; + char entity_pool_str2078[sizeof("mapstoup")]; + char entity_pool_str2079[sizeof("lcub")]; + char entity_pool_str2081[sizeof("zfr")]; + char entity_pool_str2084[sizeof("uparrow")]; + char entity_pool_str2086[sizeof("gne")]; + char entity_pool_str2090[sizeof("sce")]; + char entity_pool_str2091[sizeof("Im")]; + char entity_pool_str2096[sizeof("rcaron")]; + char entity_pool_str2098[sizeof("lcaron")]; + char entity_pool_str2099[sizeof("Oopf")]; + char entity_pool_str2100[sizeof("scaron")]; + char entity_pool_str2101[sizeof("backsim")]; + char entity_pool_str2102[sizeof("Tcaron")]; + char entity_pool_str2103[sizeof("Zcaron")]; + char entity_pool_str2104[sizeof("ecaron")]; + char entity_pool_str2106[sizeof("Bernoullis")]; + char entity_pool_str2110[sizeof("nge")]; + char entity_pool_str2111[sizeof("tcaron")]; + char entity_pool_str2113[sizeof("fork")]; + char entity_pool_str2119[sizeof("Hscr")]; + char entity_pool_str2121[sizeof("ncaron")]; + char entity_pool_str2122[sizeof("elsdot")]; + char entity_pool_str2124[sizeof("tbrk")]; + char entity_pool_str2128[sizeof("triplus")]; + char entity_pool_str2131[sizeof("diamond")]; + char entity_pool_str2134[sizeof("ncup")]; + char entity_pool_str2136[sizeof("bbrk")]; + char entity_pool_str2138[sizeof("frown")]; + char entity_pool_str2139[sizeof("bkarow")]; + char entity_pool_str2141[sizeof("spades")]; + char entity_pool_str2143[sizeof("psi")]; + char entity_pool_str2150[sizeof("Bopf")]; + char entity_pool_str2156[sizeof("dollar")]; + char entity_pool_str2164[sizeof("disin")]; + char entity_pool_str2170[sizeof("spadesuit")]; + char entity_pool_str2176[sizeof("NotTilde")]; + char entity_pool_str2177[sizeof("doublebarwedge")]; + char entity_pool_str2179[sizeof("gap")]; + char entity_pool_str2186[sizeof("bbrktbrk")]; + char entity_pool_str2189[sizeof("swarrow")]; + char entity_pool_str2190[sizeof("bepsi")]; + char entity_pool_str2194[sizeof("Iscr")]; + char entity_pool_str2198[sizeof("NotTildeFullEqual")]; + char entity_pool_str2199[sizeof("eqcolon")]; + char entity_pool_str2202[sizeof("tint")]; + char entity_pool_str2205[sizeof("intprod")]; + char entity_pool_str2207[sizeof("nsupE")]; + char entity_pool_str2210[sizeof("nwarrow")]; + char entity_pool_str2211[sizeof("nsubE")]; + char entity_pool_str2214[sizeof("nges")]; + char entity_pool_str2216[sizeof("Uparrow")]; + char entity_pool_str2217[sizeof("ge")]; + char entity_pool_str2218[sizeof("OpenCurlyDoubleQuote")]; + char entity_pool_str2223[sizeof("smallsetminus")]; + char entity_pool_str2228[sizeof("Scaron")]; + char entity_pool_str2230[sizeof("nvltrie")]; + char entity_pool_str2231[sizeof("ges")]; + char entity_pool_str2232[sizeof("blank")]; + char entity_pool_str2233[sizeof("QUOT")]; + char entity_pool_str2238[sizeof("block")]; + char entity_pool_str2239[sizeof("trade")]; + char entity_pool_str2245[sizeof("jscr")]; + char entity_pool_str2246[sizeof("wedge")]; + char entity_pool_str2254[sizeof("Amacr")]; + char entity_pool_str2256[sizeof("Equal")]; + char entity_pool_str2259[sizeof("Dcaron")]; + char entity_pool_str2262[sizeof("DotDot")]; + char entity_pool_str2270[sizeof("gneq")]; + char entity_pool_str2271[sizeof("varpropto")]; + char entity_pool_str2273[sizeof("gneqq")]; + char entity_pool_str2274[sizeof("Proportional")]; + char entity_pool_str2279[sizeof("isins")]; + char entity_pool_str2281[sizeof("eDDot")]; + char entity_pool_str2282[sizeof("isin")]; + char entity_pool_str2286[sizeof("TripleDot")]; + char entity_pool_str2290[sizeof("Fouriertrf")]; + char entity_pool_str2291[sizeof("Proportion")]; + char entity_pool_str2294[sizeof("ngeq")]; + char entity_pool_str2295[sizeof("Lcaron")]; + char entity_pool_str2297[sizeof("ngeqq")]; + char entity_pool_str2313[sizeof("lE")]; + char entity_pool_str2314[sizeof("Ccaron")]; + char entity_pool_str2320[sizeof("bsemi")]; + char entity_pool_str2326[sizeof("propto")]; + char entity_pool_str2331[sizeof("lesdot")]; + char entity_pool_str2332[sizeof("Conint")]; + char entity_pool_str2334[sizeof("And")]; + char entity_pool_str2338[sizeof("searrow")]; + char entity_pool_str2343[sizeof("orslope")]; + char entity_pool_str2344[sizeof("harr")]; + char entity_pool_str2350[sizeof("late")]; + char entity_pool_str2352[sizeof("CenterDot")]; + char entity_pool_str2355[sizeof("ofr")]; + char entity_pool_str2359[sizeof("nearrow")]; + char entity_pool_str2361[sizeof("qint")]; + char entity_pool_str2364[sizeof("lates")]; + char entity_pool_str2365[sizeof("kappav")]; + char entity_pool_str2368[sizeof("horbar")]; + char entity_pool_str2369[sizeof("Efr")]; + char entity_pool_str2370[sizeof("hoarr")]; + char entity_pool_str2371[sizeof("npre")]; + char entity_pool_str2377[sizeof("inodot")]; + char entity_pool_str2379[sizeof("udarr")]; + char entity_pool_str2386[sizeof("geq")]; + char entity_pool_str2391[sizeof("nsimeq")]; + char entity_pool_str2404[sizeof("geqq")]; + char entity_pool_str2407[sizeof("efDot")]; + char entity_pool_str2410[sizeof("rpargt")]; + char entity_pool_str2419[sizeof("Oscr")]; + char entity_pool_str2422[sizeof("plusdo")]; + char entity_pool_str2425[sizeof("lagran")]; + char entity_pool_str2429[sizeof("thicksim")]; + char entity_pool_str2440[sizeof("precnsim")]; + char entity_pool_str2444[sizeof("Ncaron")]; + char entity_pool_str2449[sizeof("napE")]; + char entity_pool_str2457[sizeof("iiint")]; + char entity_pool_str2470[sizeof("Bscr")]; + char entity_pool_str2483[sizeof("mapstodown")]; + char entity_pool_str2486[sizeof("varrho")]; + char entity_pool_str2488[sizeof("isinsv")]; + char entity_pool_str2491[sizeof("nvHarr")]; + char entity_pool_str2494[sizeof("NotLeftTriangleBar")]; + char entity_pool_str2496[sizeof("equest")]; + char entity_pool_str2498[sizeof("NotLeftTriangleEqual")]; + char entity_pool_str2499[sizeof("NotLeftTriangle")]; + char entity_pool_str2502[sizeof("Aopf")]; + char entity_pool_str2503[sizeof("hbar")]; + char entity_pool_str2507[sizeof("vangrt")]; + char entity_pool_str2511[sizeof("Hfr")]; + char entity_pool_str2517[sizeof("range")]; + char entity_pool_str2518[sizeof("smte")]; + char entity_pool_str2519[sizeof("lsim")]; + char entity_pool_str2521[sizeof("npolint")]; + char entity_pool_str2523[sizeof("dcaron")]; + char entity_pool_str2525[sizeof("esim")]; + char entity_pool_str2527[sizeof("Union")]; + char entity_pool_str2532[sizeof("smtes")]; + char entity_pool_str2536[sizeof("kopf")]; + char entity_pool_str2537[sizeof("gopf")]; + char entity_pool_str2542[sizeof("nsim")]; + char entity_pool_str2544[sizeof("bsim")]; + char entity_pool_str2546[sizeof("SmallCircle")]; + char entity_pool_str2548[sizeof("NotDoubleVerticalBar")]; + char entity_pool_str2549[sizeof("NotNestedGreaterGreater")]; + char entity_pool_str2565[sizeof("EqualTilde")]; + char entity_pool_str2568[sizeof("notindot")]; + char entity_pool_str2572[sizeof("Rcaron")]; + char entity_pool_str2577[sizeof("Popf")]; + char entity_pool_str2583[sizeof("Gopf")]; + char entity_pool_str2586[sizeof("Ifr")]; + char entity_pool_str2589[sizeof("wedgeq")]; + char entity_pool_str2595[sizeof("prod")]; + char entity_pool_str2617[sizeof("osol")]; + char entity_pool_str2624[sizeof("DoubleUpArrow")]; + char entity_pool_str2627[sizeof("Congruent")]; + char entity_pool_str2631[sizeof("gnsim")]; + char entity_pool_str2635[sizeof("scsim")]; + char entity_pool_str2637[sizeof("jfr")]; + char entity_pool_str2645[sizeof("upsih")]; + char entity_pool_str2650[sizeof("nLl")]; + char entity_pool_str2653[sizeof("DoubleUpDownArrow")]; + char entity_pool_str2655[sizeof("ngsim")]; + char entity_pool_str2664[sizeof("hearts")]; + char entity_pool_str2666[sizeof("lesseqgtr")]; + char entity_pool_str2670[sizeof("nesear")]; + char entity_pool_str2676[sizeof("Exists")]; + char entity_pool_str2687[sizeof("smile")]; + char entity_pool_str2689[sizeof("uwangle")]; + char entity_pool_str2693[sizeof("heartsuit")]; + char entity_pool_str2700[sizeof("HorizontalLine")]; + char entity_pool_str2703[sizeof("GreaterLess")]; + char entity_pool_str2705[sizeof("rsaquo")]; + char entity_pool_str2707[sizeof("lsaquo")]; + char entity_pool_str2709[sizeof("realine")]; + char entity_pool_str2710[sizeof("Dashv")]; + char entity_pool_str2714[sizeof("simdot")]; + char entity_pool_str2715[sizeof("GreaterEqual")]; + char entity_pool_str2716[sizeof("GreaterTilde")]; + char entity_pool_str2721[sizeof("GreaterEqualLess")]; + char entity_pool_str2723[sizeof("GreaterGreater")]; + char entity_pool_str2737[sizeof("rceil")]; + char entity_pool_str2739[sizeof("lceil")]; + char entity_pool_str2743[sizeof("lessgtr")]; + char entity_pool_str2746[sizeof("oline")]; + char entity_pool_str2753[sizeof("thksim")]; + char entity_pool_str2755[sizeof("InvisibleTimes")]; + char entity_pool_str2762[sizeof("race")]; + char entity_pool_str2766[sizeof("iquest")]; + char entity_pool_str2774[sizeof("imagline")]; + char entity_pool_str2779[sizeof("UpTee")]; + char entity_pool_str2781[sizeof("midcir")]; + char entity_pool_str2790[sizeof("ofcir")]; + char entity_pool_str2793[sizeof("ddarr")]; + char entity_pool_str2800[sizeof("rangd")]; + char entity_pool_str2802[sizeof("langd")]; + char entity_pool_str2808[sizeof("Equilibrium")]; + char entity_pool_str2809[sizeof("parsim")]; + char entity_pool_str2810[sizeof("Vdashl")]; + char entity_pool_str2811[sizeof("Ofr")]; + char entity_pool_str2816[sizeof("Because")]; + char entity_pool_str2818[sizeof("rAtail")]; + char entity_pool_str2820[sizeof("lAtail")]; + char entity_pool_str2821[sizeof("ominus")]; + char entity_pool_str2822[sizeof("Ascr")]; + char entity_pool_str2826[sizeof("Epsilon")]; + char entity_pool_str2832[sizeof("ShortLeftArrow")]; + char entity_pool_str2845[sizeof("isinv")]; + char entity_pool_str2847[sizeof("micro")]; + char entity_pool_str2851[sizeof("zcaron")]; + char entity_pool_str2856[sizeof("kscr")]; + char entity_pool_str2857[sizeof("gscr")]; + char entity_pool_str2862[sizeof("Bfr")]; + char entity_pool_str2863[sizeof("gel")]; + char entity_pool_str2864[sizeof("hercon")]; + char entity_pool_str2871[sizeof("triminus")]; + char entity_pool_str2877[sizeof("egrave")]; + char entity_pool_str2881[sizeof("sdot")]; + char entity_pool_str2882[sizeof("ugrave")]; + char entity_pool_str2884[sizeof("Zdot")]; + char entity_pool_str2885[sizeof("edot")]; + char entity_pool_str2890[sizeof("NotTildeTilde")]; + char entity_pool_str2892[sizeof("tdot")]; + char entity_pool_str2897[sizeof("Pscr")]; + char entity_pool_str2898[sizeof("Pi")]; + char entity_pool_str2903[sizeof("Gscr")]; + char entity_pool_str2910[sizeof("plustwo")]; + char entity_pool_str2914[sizeof("NotElement")]; + char entity_pool_str2916[sizeof("PlusMinus")]; + char entity_pool_str2919[sizeof("hopf")]; + char entity_pool_str2920[sizeof("gammad")]; + char entity_pool_str2922[sizeof("mDDot")]; + char entity_pool_str2926[sizeof("divideontimes")]; + char entity_pool_str2940[sizeof("doteq")]; + char entity_pool_str2956[sizeof("varepsilon")]; + char entity_pool_str2963[sizeof("Precedes")]; + char entity_pool_str2966[sizeof("Gammad")]; + char entity_pool_str2974[sizeof("dashv")]; + char entity_pool_str2979[sizeof("NotCongruent")]; + char entity_pool_str2982[sizeof("ubreve")]; + char entity_pool_str2990[sizeof("ogt")]; + char entity_pool_str2994[sizeof("RoundImplies")]; + char entity_pool_str3002[sizeof("PrecedesSlantEqual")]; + char entity_pool_str3005[sizeof("sime")]; + char entity_pool_str3014[sizeof("Ugrave")]; + char entity_pool_str3016[sizeof("dbkarow")]; + char entity_pool_str3021[sizeof("sdote")]; + char entity_pool_str3023[sizeof("veeeq")]; + char entity_pool_str3027[sizeof("mapsto")]; + char entity_pool_str3030[sizeof("times")]; + char entity_pool_str3033[sizeof("rangle")]; + char entity_pool_str3035[sizeof("langle")]; + char entity_pool_str3038[sizeof("leftarrowtail")]; + char entity_pool_str3039[sizeof("hamilt")]; + char entity_pool_str3044[sizeof("udhar")]; + char entity_pool_str3053[sizeof("nisd")]; + char entity_pool_str3055[sizeof("rfisht")]; + char entity_pool_str3057[sizeof("lfisht")]; + char entity_pool_str3058[sizeof("harrcir")]; + char entity_pool_str3066[sizeof("OpenCurlyQuote")]; + char entity_pool_str3068[sizeof("ufisht")]; + char entity_pool_str3069[sizeof("NotHumpDownHump")]; + char entity_pool_str3072[sizeof("LeftTee")]; + char entity_pool_str3074[sizeof("rsh")]; + char entity_pool_str3076[sizeof("lsh")]; + char entity_pool_str3080[sizeof("gvertneqq")]; + char entity_pool_str3083[sizeof("timesb")]; + char entity_pool_str3092[sizeof("scpolint")]; + char entity_pool_str3095[sizeof("Cdot")]; + char entity_pool_str3103[sizeof("dwangle")]; + char entity_pool_str3114[sizeof("Ubreve")]; + char entity_pool_str3132[sizeof("LeftUpVector")]; + char entity_pool_str3135[sizeof("LeftUpVectorBar")]; + char entity_pool_str3139[sizeof("Ecaron")]; + char entity_pool_str3142[sizeof("homtht")]; + char entity_pool_str3147[sizeof("igrave")]; + char entity_pool_str3155[sizeof("npreceq")]; + char entity_pool_str3156[sizeof("ecolon")]; + char entity_pool_str3167[sizeof("dd")]; + char entity_pool_str3174[sizeof("simeq")]; + char entity_pool_str3179[sizeof("notinE")]; + char entity_pool_str3198[sizeof("bigoplus")]; + char entity_pool_str3214[sizeof("Afr")]; + char entity_pool_str3215[sizeof("leftarrow")]; + char entity_pool_str3216[sizeof("oint")]; + char entity_pool_str3218[sizeof("Tab")]; + char entity_pool_str3227[sizeof("ogon")]; + char entity_pool_str3230[sizeof("lt")]; + char entity_pool_str3231[sizeof("nLeftrightarrow")]; + char entity_pool_str3235[sizeof("rarrb")]; + char entity_pool_str3237[sizeof("larrb")]; + char entity_pool_str3239[sizeof("hscr")]; + char entity_pool_str3246[sizeof("LeftUpDownVector")]; + char entity_pool_str3248[sizeof("kfr")]; + char entity_pool_str3249[sizeof("gfr")]; + char entity_pool_str3250[sizeof("UpArrowBar")]; + char entity_pool_str3259[sizeof("nsce")]; + char entity_pool_str3260[sizeof("ltdot")]; + char entity_pool_str3261[sizeof("gesl")]; + char entity_pool_str3262[sizeof("xodot")]; + char entity_pool_str3263[sizeof("star")]; + char entity_pool_str3266[sizeof("lowbar")]; + char entity_pool_str3268[sizeof("xharr")]; + char entity_pool_str3269[sizeof("ecir")]; + char entity_pool_str3271[sizeof("utdot")]; + char entity_pool_str3272[sizeof("natur")]; + char entity_pool_str3273[sizeof("Lsh")]; + char entity_pool_str3274[sizeof("infin")]; + char entity_pool_str3276[sizeof("comp")]; + char entity_pool_str3278[sizeof("sigmav")]; + char entity_pool_str3285[sizeof("xotime")]; + char entity_pool_str3289[sizeof("Pfr")]; + char entity_pool_str3295[sizeof("Gfr")]; + char entity_pool_str3298[sizeof("bigcap")]; + char entity_pool_str3300[sizeof("simlE")]; + char entity_pool_str3319[sizeof("iiiint")]; + char entity_pool_str3320[sizeof("barwedge")]; + char entity_pool_str3321[sizeof("Barwed")]; + char entity_pool_str3329[sizeof("xlarr")]; + char entity_pool_str3330[sizeof("LessEqualGreater")]; + char entity_pool_str3332[sizeof("crarr")]; + char entity_pool_str3333[sizeof("isindot")]; + char entity_pool_str3335[sizeof("commat")]; + char entity_pool_str3342[sizeof("middot")]; + char entity_pool_str3349[sizeof("lesdotor")]; + char entity_pool_str3356[sizeof("sigmaf")]; + char entity_pool_str3366[sizeof("rarrbfs")]; + char entity_pool_str3368[sizeof("larrbfs")]; + char entity_pool_str3371[sizeof("xrarr")]; + char entity_pool_str3376[sizeof("bigcup")]; + char entity_pool_str3378[sizeof("clubs")]; + char entity_pool_str3379[sizeof("hArr")]; + char entity_pool_str3380[sizeof("rtrie")]; + char entity_pool_str3382[sizeof("ltrie")]; + char entity_pool_str3383[sizeof("imped")]; + char entity_pool_str3388[sizeof("eogon")]; + char entity_pool_str3389[sizeof("rx")]; + char entity_pool_str3390[sizeof("ltrPar")]; + char entity_pool_str3391[sizeof("Star")]; + char entity_pool_str3393[sizeof("uogon")]; + char entity_pool_str3396[sizeof("Tilde")]; + char entity_pool_str3398[sizeof("half")]; + char entity_pool_str3405[sizeof("tilde")]; + char entity_pool_str3412[sizeof("Leftarrow")]; + char entity_pool_str3417[sizeof("gesles")]; + char entity_pool_str3422[sizeof("cap")]; + char entity_pool_str3423[sizeof("strns")]; + char entity_pool_str3427[sizeof("Lt")]; + char entity_pool_str3439[sizeof("prnE")]; + char entity_pool_str3447[sizeof("sqsupe")]; + char entity_pool_str3462[sizeof("sqsupset")]; + char entity_pool_str3467[sizeof("tridot")]; + char entity_pool_str3468[sizeof("order")]; + char entity_pool_str3471[sizeof("caps")]; + char entity_pool_str3475[sizeof("cross")]; + char entity_pool_str3482[sizeof("dfisht")]; + char entity_pool_str3487[sizeof("xmap")]; + char entity_pool_str3491[sizeof("sqsup")]; + char entity_pool_str3503[sizeof("rtri")]; + char entity_pool_str3505[sizeof("ltri")]; + char entity_pool_str3506[sizeof("it")]; + char entity_pool_str3507[sizeof("rmoust")]; + char entity_pool_str3509[sizeof("lmoust")]; + char entity_pool_str3510[sizeof("gnE")]; + char entity_pool_str3511[sizeof("lgE")]; + char entity_pool_str3514[sizeof("scE")]; + char entity_pool_str3516[sizeof("utri")]; + char entity_pool_str3518[sizeof("vellip")]; + char entity_pool_str3520[sizeof("ETH")]; + char entity_pool_str3523[sizeof("lmidot")]; + char entity_pool_str3525[sizeof("Uogon")]; + char entity_pool_str3526[sizeof("CounterClockwiseContourIntegral")]; + char entity_pool_str3534[sizeof("ngE")]; + char entity_pool_str3535[sizeof("nwnear")]; + char entity_pool_str3543[sizeof("lesg")]; + char entity_pool_str3546[sizeof("plusb")]; + char entity_pool_str3550[sizeof("Rsh")]; + char entity_pool_str3555[sizeof("copysr")]; + char entity_pool_str3557[sizeof("infintie")]; + char entity_pool_str3559[sizeof("imath")]; + char entity_pool_str3560[sizeof("Esim")]; + char entity_pool_str3565[sizeof("Phi")]; + char entity_pool_str3573[sizeof("glE")]; + char entity_pool_str3579[sizeof("vnsup")]; + char entity_pool_str3582[sizeof("simgE")]; + char entity_pool_str3586[sizeof("DoubleLongLeftArrow")]; + char entity_pool_str3591[sizeof("DoubleLongLeftRightArrow")]; + char entity_pool_str3594[sizeof("nvgt")]; + char entity_pool_str3607[sizeof("Mellintrf")]; + char entity_pool_str3611[sizeof("Prime")]; + char entity_pool_str3615[sizeof("iinfin")]; + char entity_pool_str3620[sizeof("ReverseElement")]; + char entity_pool_str3627[sizeof("EmptySmallSquare")]; + char entity_pool_str3628[sizeof("radic")]; + char entity_pool_str3631[sizeof("hfr")]; + char entity_pool_str3632[sizeof("zdot")]; + char entity_pool_str3633[sizeof("male")]; + char entity_pool_str3635[sizeof("rarrc")]; + char entity_pool_str3636[sizeof("prec")]; + char entity_pool_str3637[sizeof("scnap")]; + char entity_pool_str3641[sizeof("DifferentialD")]; + char entity_pool_str3643[sizeof("models")]; + char entity_pool_str3657[sizeof("ltcir")]; + char entity_pool_str3658[sizeof("iogon")]; + char entity_pool_str3665[sizeof("capcap")]; + char entity_pool_str3667[sizeof("iff")]; + char entity_pool_str3669[sizeof("ddotseq")]; + char entity_pool_str3671[sizeof("CirclePlus")]; + char entity_pool_str3676[sizeof("rthree")]; + char entity_pool_str3678[sizeof("lthree")]; + char entity_pool_str3681[sizeof("PrecedesTilde")]; + char entity_pool_str3685[sizeof("dtdot")]; + char entity_pool_str3687[sizeof("clubsuit")]; + char entity_pool_str3689[sizeof("racute")]; + char entity_pool_str3691[sizeof("lacute")]; + char entity_pool_str3692[sizeof("trpezium")]; + char entity_pool_str3693[sizeof("sacute")]; + char entity_pool_str3696[sizeof("Zacute")]; + char entity_pool_str3697[sizeof("eacute")]; + char entity_pool_str3699[sizeof("TildeTilde")]; + char entity_pool_str3701[sizeof("Uarrocir")]; + char entity_pool_str3702[sizeof("uacute")]; + char entity_pool_str3703[sizeof("lowast")]; + char entity_pool_str3714[sizeof("nacute")]; + char entity_pool_str3716[sizeof("NotPrecedes")]; + char entity_pool_str3720[sizeof("Lmidot")]; + char entity_pool_str3725[sizeof("UpArrow")]; + char entity_pool_str3727[sizeof("rarrw")]; + char entity_pool_str3738[sizeof("DownTee")]; + char entity_pool_str3742[sizeof("FilledSmallSquare")]; + char entity_pool_str3743[sizeof("capcup")]; + char entity_pool_str3749[sizeof("GreaterFullEqual")]; + char entity_pool_str3756[sizeof("nvle")]; + char entity_pool_str3758[sizeof("trie")]; + char entity_pool_str3764[sizeof("omicron")]; + char entity_pool_str3766[sizeof("DoubleRightTee")]; + char entity_pool_str3767[sizeof("Cconint")]; + char entity_pool_str3768[sizeof("rsquor")]; + char entity_pool_str3770[sizeof("lsquor")]; + char entity_pool_str3772[sizeof("zigrarr")]; + char entity_pool_str3780[sizeof("copf")]; + char entity_pool_str3782[sizeof("ContourIntegral")]; + char entity_pool_str3798[sizeof("hairsp")]; + char entity_pool_str3799[sizeof("sqsupseteq")]; + char entity_pool_str3800[sizeof("csub")]; + char entity_pool_str3801[sizeof("upharpoonright")]; + char entity_pool_str3805[sizeof("DownBreve")]; + char entity_pool_str3817[sizeof("ShortDownArrow")]; + char entity_pool_str3819[sizeof("xopf")]; + char entity_pool_str3821[sizeof("Sacute")]; + char entity_pool_str3829[sizeof("vsupnE")]; + char entity_pool_str3830[sizeof("cir")]; + char entity_pool_str3831[sizeof("plusacir")]; + char entity_pool_str3832[sizeof("csup")]; + char entity_pool_str3833[sizeof("vsubnE")]; + char entity_pool_str3834[sizeof("Uacute")]; + char entity_pool_str3836[sizeof("isinE")]; + char entity_pool_str3845[sizeof("gEl")]; + char entity_pool_str3851[sizeof("sqcups")]; + char entity_pool_str3853[sizeof("smid")]; + char entity_pool_str3855[sizeof("lg")]; + char entity_pool_str3857[sizeof("DoubleLongRightArrow")]; + char entity_pool_str3858[sizeof("NotPrecedesSlantEqual")]; + char entity_pool_str3861[sizeof("eg")]; + char entity_pool_str3864[sizeof("AMP")]; + char entity_pool_str3874[sizeof("nmid")]; + char entity_pool_str3883[sizeof("timesd")]; + char entity_pool_str3886[sizeof("DownLeftVector")]; + char entity_pool_str3887[sizeof("zwnj")]; + char entity_pool_str3888[sizeof("Lacute")]; + char entity_pool_str3889[sizeof("DownLeftVectorBar")]; + char entity_pool_str3898[sizeof("ograve")]; + char entity_pool_str3899[sizeof("Yacute")]; + char entity_pool_str3903[sizeof("sqcup")]; + char entity_pool_str3906[sizeof("odot")]; + char entity_pool_str3907[sizeof("Cacute")]; + char entity_pool_str3909[sizeof("nu")]; + char entity_pool_str3910[sizeof("tritime")]; + char entity_pool_str3912[sizeof("Egrave")]; + char entity_pool_str3913[sizeof("eplus")]; + char entity_pool_str3915[sizeof("backcong")]; + char entity_pool_str3918[sizeof("uplus")]; + char entity_pool_str3920[sizeof("Edot")]; + char entity_pool_str3924[sizeof("csupe")]; + char entity_pool_str3926[sizeof("simg")]; + char entity_pool_str3927[sizeof("UpperRightArrow")]; + char entity_pool_str3928[sizeof("csube")]; + char entity_pool_str3930[sizeof("dtri")]; + char entity_pool_str3931[sizeof("prnsim")]; + char entity_pool_str3936[sizeof("boxUr")]; + char entity_pool_str3937[sizeof("uuarr")]; + char entity_pool_str3945[sizeof("DownLeftTeeVector")]; + char entity_pool_str3946[sizeof("gsime")]; + char entity_pool_str3950[sizeof("bigotimes")]; + char entity_pool_str3951[sizeof("Dagger")]; + char entity_pool_str3954[sizeof("Intersection")]; + char entity_pool_str3967[sizeof("iacute")]; + char entity_pool_str3969[sizeof("prcue")]; + char entity_pool_str3981[sizeof("egsdot")]; + char entity_pool_str3987[sizeof("Implies")]; + char entity_pool_str3988[sizeof("VDash")]; + char entity_pool_str3996[sizeof("bump")]; + char entity_pool_str4015[sizeof("Mu")]; + char entity_pool_str4022[sizeof("vDash")]; + char entity_pool_str4028[sizeof("lvnE")]; + char entity_pool_str4033[sizeof("LeftTeeArrow")]; + char entity_pool_str4037[sizeof("Nacute")]; + char entity_pool_str4042[sizeof("UnderBrace")]; + char entity_pool_str4043[sizeof("Psi")]; + char entity_pool_str4047[sizeof("rhov")]; + char entity_pool_str4049[sizeof("lescc")]; + char entity_pool_str4055[sizeof("sup1")]; + char entity_pool_str4058[sizeof("sup2")]; + char entity_pool_str4066[sizeof("sup3")]; + char entity_pool_str4071[sizeof("bigodot")]; + char entity_pool_str4078[sizeof("Downarrow")]; + char entity_pool_str4080[sizeof("xsqcup")]; + char entity_pool_str4082[sizeof("barvee")]; + char entity_pool_str4087[sizeof("NegativeMediumSpace")]; + char entity_pool_str4088[sizeof("bumpe")]; + char entity_pool_str4100[sizeof("cscr")]; + char entity_pool_str4109[sizeof("nsc")]; + char entity_pool_str4115[sizeof("sup")]; + char entity_pool_str4122[sizeof("cedil")]; + char entity_pool_str4125[sizeof("boxVr")]; + char entity_pool_str4127[sizeof("origof")]; + char entity_pool_str4128[sizeof("zwj")]; + char entity_pool_str4129[sizeof("Igrave")]; + char entity_pool_str4137[sizeof("Idot")]; + char entity_pool_str4139[sizeof("xscr")]; + char entity_pool_str4140[sizeof("xi")]; + char entity_pool_str4144[sizeof("nGtv")]; + char entity_pool_str4153[sizeof("boxHu")]; + char entity_pool_str4163[sizeof("THORN")]; + char entity_pool_str4165[sizeof("Racute")]; + char entity_pool_str4167[sizeof("rarrhk")]; + char entity_pool_str4169[sizeof("larrhk")]; + char entity_pool_str4177[sizeof("rtriltri")]; + char entity_pool_str4189[sizeof("boxV")]; + char entity_pool_str4215[sizeof("dagger")]; + char entity_pool_str4220[sizeof("Omicron")]; + char entity_pool_str4226[sizeof("DoubleVerticalBar")]; + char entity_pool_str4229[sizeof("nexists")]; + char entity_pool_str4232[sizeof("Nu")]; + char entity_pool_str4233[sizeof("nexist")]; + char entity_pool_str4234[sizeof("gE")]; + char entity_pool_str4238[sizeof("ap")]; + char entity_pool_str4243[sizeof("Sup")]; + char entity_pool_str4244[sizeof("doteqdot")]; + char entity_pool_str4247[sizeof("eng")]; + char entity_pool_str4249[sizeof("caron")]; + char entity_pool_str4251[sizeof("boxHU")]; + char entity_pool_str4252[sizeof("gesdot")]; + char entity_pool_str4257[sizeof("ReverseEquilibrium")]; + char entity_pool_str4262[sizeof("boxUL")]; + char entity_pool_str4264[sizeof("supmult")]; + char entity_pool_str4267[sizeof("pitchfork")]; + char entity_pool_str4272[sizeof("numsp")]; + char entity_pool_str4285[sizeof("rang")]; + char entity_pool_str4287[sizeof("lang")]; + char entity_pool_str4290[sizeof("ocir")]; + char entity_pool_str4292[sizeof("rationals")]; + char entity_pool_str4294[sizeof("coprod")]; + char entity_pool_str4307[sizeof("ltlarr")]; + char entity_pool_str4308[sizeof("breve")]; + char entity_pool_str4310[sizeof("nang")]; + char entity_pool_str4315[sizeof("swarhk")]; + char entity_pool_str4322[sizeof("raquo")]; + char entity_pool_str4324[sizeof("laquo")]; + char entity_pool_str4325[sizeof("supsub")]; + char entity_pool_str4329[sizeof("Cup")]; + char entity_pool_str4330[sizeof("ape")]; + char entity_pool_str4331[sizeof("quest")]; + char entity_pool_str4336[sizeof("nwarhk")]; + char entity_pool_str4340[sizeof("supset")]; + char entity_pool_str4342[sizeof("downarrow")]; + char entity_pool_str4351[sizeof("duarr")]; + char entity_pool_str4353[sizeof("apos")]; + char entity_pool_str4354[sizeof("Ograve")]; + char entity_pool_str4355[sizeof("shortparallel")]; + char entity_pool_str4364[sizeof("nsucc")]; + char entity_pool_str4368[sizeof("LongLeftArrow")]; + char entity_pool_str4377[sizeof("lesdoto")]; + char entity_pool_str4384[sizeof("supne")]; + char entity_pool_str4388[sizeof("nGg")]; + char entity_pool_str4396[sizeof("raemptyv")]; + char entity_pool_str4397[sizeof("supsup")]; + char entity_pool_str4398[sizeof("laemptyv")]; + char entity_pool_str4401[sizeof("topfork")]; + char entity_pool_str4423[sizeof("Eogon")]; + char entity_pool_str4429[sizeof("risingdotseq")]; + char entity_pool_str4431[sizeof("bumpeq")]; + char entity_pool_str4435[sizeof("lstrok")]; + char entity_pool_str4439[sizeof("Tstrok")]; + char entity_pool_str4440[sizeof("gsim")]; + char entity_pool_str4443[sizeof("bemptyv")]; + char entity_pool_str4444[sizeof("zacute")]; + char entity_pool_str4445[sizeof("gsiml")]; + char entity_pool_str4448[sizeof("tstrok")]; + char entity_pool_str4450[sizeof("roang")]; + char entity_pool_str4451[sizeof("boxVL")]; + char entity_pool_str4452[sizeof("loang")]; + char entity_pool_str4456[sizeof("nleqslant")]; + char entity_pool_str4462[sizeof("sbquo")]; + char entity_pool_str4464[sizeof("searhk")]; + char entity_pool_str4465[sizeof("lnapprox")]; + char entity_pool_str4468[sizeof("Supset")]; + char entity_pool_str4470[sizeof("boxHd")]; + char entity_pool_str4471[sizeof("varkappa")]; + char entity_pool_str4475[sizeof("circeq")]; + char entity_pool_str4477[sizeof("yopf")]; + char entity_pool_str4479[sizeof("UnionPlus")]; + char entity_pool_str4484[sizeof("Lang")]; + char entity_pool_str4485[sizeof("nearhk")]; + char entity_pool_str4486[sizeof("shcy")]; + char entity_pool_str4492[sizeof("cfr")]; + char entity_pool_str4506[sizeof("Kappa")]; + char entity_pool_str4507[sizeof("ljcy")]; + char entity_pool_str4508[sizeof("MediumSpace")]; + char entity_pool_str4511[sizeof("supseteq")]; + char entity_pool_str4512[sizeof("supseteqq")]; + char entity_pool_str4517[sizeof("reg")]; + char entity_pool_str4518[sizeof("amacr")]; + char entity_pool_str4519[sizeof("leg")]; + char entity_pool_str4524[sizeof("weierp")]; + char entity_pool_str4525[sizeof("TScy")]; + char entity_pool_str4529[sizeof("supsetneq")]; + char entity_pool_str4530[sizeof("njcy")]; + char entity_pool_str4531[sizeof("xfr")]; + char entity_pool_str4533[sizeof("mu")]; + char entity_pool_str4539[sizeof("nvinfin")]; + char entity_pool_str4540[sizeof("boxUR")]; + char entity_pool_str4545[sizeof("xoplus")]; + char entity_pool_str4551[sizeof("leftleftarrows")]; + char entity_pool_str4552[sizeof("sum")]; + char entity_pool_str4559[sizeof("beth")]; + char entity_pool_str4563[sizeof("complement")]; + char entity_pool_str4573[sizeof("num")]; + char entity_pool_str4574[sizeof("amp")]; + char entity_pool_str4583[sizeof("boxUl")]; + char entity_pool_str4590[sizeof("NotGreater")]; + char entity_pool_str4591[sizeof("boxplus")]; + char entity_pool_str4592[sizeof("jmath")]; + char entity_pool_str4594[sizeof("sfrown")]; + char entity_pool_str4596[sizeof("Dstrok")]; + char entity_pool_str4598[sizeof("and")]; + char entity_pool_str4599[sizeof("NotGreaterGreater")]; + char entity_pool_str4606[sizeof("NotGreaterSlantEqual")]; + char entity_pool_str4608[sizeof("NotGreaterLess")]; + char entity_pool_str4609[sizeof("quot")]; + char entity_pool_str4616[sizeof("NotGreaterFullEqual")]; + char entity_pool_str4617[sizeof("hyphen")]; + char entity_pool_str4618[sizeof("planck")]; + char entity_pool_str4620[sizeof("TildeEqual")]; + char entity_pool_str4627[sizeof("tosa")]; + char entity_pool_str4632[sizeof("Lstrok")]; + char entity_pool_str4635[sizeof("shy")]; + char entity_pool_str4639[sizeof("xnis")]; + char entity_pool_str4640[sizeof("Iogon")]; + char entity_pool_str4643[sizeof("DZcy")]; + char entity_pool_str4645[sizeof("ohbar")]; + char entity_pool_str4652[sizeof("cirscir")]; + char entity_pool_str4654[sizeof("sext")]; + char entity_pool_str4668[sizeof("para")]; + char entity_pool_str4671[sizeof("ast")]; + char entity_pool_str4678[sizeof("questeq")]; + char entity_pool_str4680[sizeof("Sum")]; + char entity_pool_str4682[sizeof("DScy")]; + char entity_pool_str4684[sizeof("ENG")]; + char entity_pool_str4686[sizeof("ZHcy")]; + char entity_pool_str4689[sizeof("longleftarrow")]; + char entity_pool_str4691[sizeof("dash")]; + char entity_pool_str4699[sizeof("DownTeeArrow")]; + char entity_pool_str4706[sizeof("supsetneqq")]; + char entity_pool_str4714[sizeof("profalar")]; + char entity_pool_str4718[sizeof("oacute")]; + char entity_pool_str4729[sizeof("boxVR")]; + char entity_pool_str4732[sizeof("Eacute")]; + char entity_pool_str4738[sizeof("supplus")]; + char entity_pool_str4740[sizeof("hookleftarrow")]; + char entity_pool_str4743[sizeof("CloseCurlyQuote")]; + char entity_pool_str4746[sizeof("trisb")]; + char entity_pool_str4747[sizeof("dotsquare")]; + char entity_pool_str4751[sizeof("rtimes")]; + char entity_pool_str4753[sizeof("ltimes")]; + char entity_pool_str4756[sizeof("toea")]; + char entity_pool_str4757[sizeof("Agrave")]; + char entity_pool_str4760[sizeof("Assign")]; + char entity_pool_str4761[sizeof("Rang")]; + char entity_pool_str4762[sizeof("iocy")]; + char entity_pool_str4764[sizeof("NotPrecedesEqual")]; + char entity_pool_str4766[sizeof("aopf")]; + char entity_pool_str4768[sizeof("chi")]; + char entity_pool_str4771[sizeof("quaternions")]; + char entity_pool_str4772[sizeof("boxVl")]; + char entity_pool_str4773[sizeof("NotGreaterEqual")]; + char entity_pool_str4777[sizeof("xhArr")]; + char entity_pool_str4791[sizeof("orderof")]; + char entity_pool_str4794[sizeof("rsquo")]; + char entity_pool_str4796[sizeof("lsquo")]; + char entity_pool_str4797[sizeof("yscr")]; + char entity_pool_str4800[sizeof("gdot")]; + char entity_pool_str4802[sizeof("NotSquareSubsetEqual")]; + char entity_pool_str4803[sizeof("KHcy")]; + char entity_pool_str4809[sizeof("bsolb")]; + char entity_pool_str4810[sizeof("NotSquareSubset")]; + char entity_pool_str4811[sizeof("SHcy")]; + char entity_pool_str4821[sizeof("YIcy")]; + char entity_pool_str4825[sizeof("cwint")]; + char entity_pool_str4828[sizeof("Theta")]; + char entity_pool_str4837[sizeof("theta")]; + char entity_pool_str4838[sizeof("xlArr")]; + char entity_pool_str4840[sizeof("NotSquareSupersetEqual")]; + char entity_pool_str4843[sizeof("demptyv")]; + char entity_pool_str4844[sizeof("triangle")]; + char entity_pool_str4846[sizeof("Gdot")]; + char entity_pool_str4848[sizeof("NotSquareSuperset")]; + char entity_pool_str4857[sizeof("Abreve")]; + char entity_pool_str4860[sizeof("dstrok")]; + char entity_pool_str4861[sizeof("pertenk")]; + char entity_pool_str4866[sizeof("rbrack")]; + char entity_pool_str4868[sizeof("lbrack")]; + char entity_pool_str4872[sizeof("odsold")]; + char entity_pool_str4878[sizeof("omid")]; + char entity_pool_str4880[sizeof("xrArr")]; + char entity_pool_str4882[sizeof("triangleleft")]; + char entity_pool_str4883[sizeof("NotGreaterTilde")]; + char entity_pool_str4884[sizeof("colone")]; + char entity_pool_str4886[sizeof("Longleftarrow")]; + char entity_pool_str4888[sizeof("iota")]; + char entity_pool_str4890[sizeof("colon")]; + char entity_pool_str4891[sizeof("Zeta")]; + char entity_pool_str4892[sizeof("gbreve")]; + char entity_pool_str4897[sizeof("CHcy")]; + char entity_pool_str4900[sizeof("YUcy")]; + char entity_pool_str4901[sizeof("REG")]; + char entity_pool_str4902[sizeof("szlig")]; + char entity_pool_str4909[sizeof("dzcy")]; + char entity_pool_str4911[sizeof("beta")]; + char entity_pool_str4918[sizeof("euro")]; + char entity_pool_str4921[sizeof("LeftArrow")]; + char entity_pool_str4924[sizeof("CapitalDifferentialD")]; + char entity_pool_str4926[sizeof("ring")]; + char entity_pool_str4927[sizeof("Laplacetrf")]; + char entity_pool_str4932[sizeof("djcy")]; + char entity_pool_str4934[sizeof("oplus")]; + char entity_pool_str4937[sizeof("integers")]; + char entity_pool_str4938[sizeof("Gbreve")]; + char entity_pool_str4940[sizeof("ubrcy")]; + char entity_pool_str4941[sizeof("euml")]; + char entity_pool_str4944[sizeof("deg")]; + char entity_pool_str4946[sizeof("uuml")]; + char entity_pool_str4949[sizeof("Iacute")]; + char entity_pool_str4950[sizeof("succeq")]; + char entity_pool_str4952[sizeof("KJcy")]; + char entity_pool_str4961[sizeof("CupCap")]; + char entity_pool_str4975[sizeof("tscy")]; + char entity_pool_str4982[sizeof("cent")]; + char entity_pool_str4991[sizeof("DJcy")]; + char entity_pool_str5009[sizeof("TildeFullEqual")]; + char entity_pool_str5011[sizeof("triangleq")]; + char entity_pool_str5016[sizeof("duhar")]; + char entity_pool_str5025[sizeof("LeftDoubleBracket")]; + char entity_pool_str5027[sizeof("LJcy")]; + char entity_pool_str5036[sizeof("iecy")]; + char entity_pool_str5043[sizeof("trianglelefteq")]; + char entity_pool_str5049[sizeof("nequiv")]; + char entity_pool_str5055[sizeof("nshortparallel")]; + char entity_pool_str5062[sizeof("ndash")]; + char entity_pool_str5063[sizeof("bowtie")]; + char entity_pool_str5065[sizeof("fjlig")]; + char entity_pool_str5072[sizeof("Ubrcy")]; + char entity_pool_str5074[sizeof("vartheta")]; + char entity_pool_str5078[sizeof("Uuml")]; + char entity_pool_str5084[sizeof("vartriangleright")]; + char entity_pool_str5085[sizeof("vartriangleleft")]; + char entity_pool_str5086[sizeof("ascr")]; + char entity_pool_str5089[sizeof("succcurlyeq")]; + char entity_pool_str5093[sizeof("cwconint")]; + char entity_pool_str5101[sizeof("sc")]; + char entity_pool_str5103[sizeof("fllig")]; + char entity_pool_str5105[sizeof("circledast")]; + char entity_pool_str5108[sizeof("Vdash")]; + char entity_pool_str5112[sizeof("nVdash")]; + char entity_pool_str5120[sizeof("suplarr")]; + char entity_pool_str5124[sizeof("robrk")]; + char entity_pool_str5126[sizeof("lobrk")]; + char entity_pool_str5142[sizeof("vdash")]; + char entity_pool_str5143[sizeof("Yuml")]; + char entity_pool_str5151[sizeof("gt")]; + char entity_pool_str5156[sizeof("ccaps")]; + char entity_pool_str5173[sizeof("Succeeds")]; + char entity_pool_str5174[sizeof("Oacute")]; + char entity_pool_str5175[sizeof("TRADE")]; + char entity_pool_str5176[sizeof("NJcy")]; + char entity_pool_str5181[sizeof("gtdot")]; + char entity_pool_str5189[sizeof("yfr")]; + char entity_pool_str5192[sizeof("compfn")]; + char entity_pool_str5197[sizeof("Gt")]; + char entity_pool_str5198[sizeof("scnE")]; + char entity_pool_str5199[sizeof("ijlig")]; + char entity_pool_str5203[sizeof("circledS")]; + char entity_pool_str5206[sizeof("yen")]; + char entity_pool_str5208[sizeof("thetasym")]; + char entity_pool_str5211[sizeof("iuml")]; + char entity_pool_str5212[sizeof("SucceedsSlantEqual")]; + char entity_pool_str5217[sizeof("boxH")]; + char entity_pool_str5218[sizeof("mumap")]; + char entity_pool_str5222[sizeof("rightrightarrows")]; + char entity_pool_str5227[sizeof("coloneq")]; + char entity_pool_str5229[sizeof("Sc")]; + char entity_pool_str5230[sizeof("glj")]; + char entity_pool_str5231[sizeof("iexcl")]; + char entity_pool_str5234[sizeof("ccups")]; + char entity_pool_str5236[sizeof("xcap")]; + char entity_pool_str5237[sizeof("zhcy")]; + char entity_pool_str5241[sizeof("boxHD")]; + char entity_pool_str5250[sizeof("leqslant")]; + char entity_pool_str5252[sizeof("UpperLeftArrow")]; + char entity_pool_str5257[sizeof("dblac")]; + char entity_pool_str5260[sizeof("puncsp")]; + char entity_pool_str5262[sizeof("ccaron")]; + char entity_pool_str5264[sizeof("rbbrk")]; + char entity_pool_str5266[sizeof("lbbrk")]; + char entity_pool_str5268[sizeof("Aogon")]; + char entity_pool_str5269[sizeof("LeftTriangleBar")]; + char entity_pool_str5272[sizeof("gesdotol")]; + char entity_pool_str5273[sizeof("LeftTriangleEqual")]; + char entity_pool_str5274[sizeof("LeftTriangle")]; + char entity_pool_str5280[sizeof("conint")]; + char entity_pool_str5283[sizeof("drbkarow")]; + char entity_pool_str5295[sizeof("rtrif")]; + char entity_pool_str5297[sizeof("ltrif")]; + char entity_pool_str5300[sizeof("ReverseUpEquilibrium")]; + char entity_pool_str5306[sizeof("LeftCeiling")]; + char entity_pool_str5308[sizeof("utrif")]; + char entity_pool_str5314[sizeof("xcup")]; + char entity_pool_str5319[sizeof("fallingdotseq")]; + char entity_pool_str5325[sizeof("rcedil")]; + char entity_pool_str5327[sizeof("lcedil")]; + char entity_pool_str5329[sizeof("scedil")]; + char entity_pool_str5331[sizeof("Tcedil")]; + char entity_pool_str5333[sizeof("starf")]; + char entity_pool_str5334[sizeof("boxminus")]; + char entity_pool_str5340[sizeof("tcedil")]; + char entity_pool_str5341[sizeof("ZeroWidthSpace")]; + char entity_pool_str5350[sizeof("ncedil")]; + char entity_pool_str5358[sizeof("phiv")]; + char entity_pool_str5375[sizeof("ic")]; + char entity_pool_str5384[sizeof("capdot")]; + char entity_pool_str5387[sizeof("dscy")]; + char entity_pool_str5397[sizeof("check")]; + char entity_pool_str5398[sizeof("ovbar")]; + char entity_pool_str5405[sizeof("ntriangleleft")]; + char entity_pool_str5411[sizeof("RightTee")]; + char entity_pool_str5412[sizeof("nvge")]; + char entity_pool_str5424[sizeof("leftrightsquigarrow")]; + char entity_pool_str5431[sizeof("lozenge")]; + char entity_pool_str5434[sizeof("RightTriangleBar")]; + char entity_pool_str5436[sizeof("RightTeeVector")]; + char entity_pool_str5438[sizeof("RightTriangleEqual")]; + char entity_pool_str5439[sizeof("RightTriangle")]; + char entity_pool_str5449[sizeof("Kcedil")]; + char entity_pool_str5457[sizeof("Scedil")]; + char entity_pool_str5468[sizeof("cirfnint")]; + char entity_pool_str5471[sizeof("empty")]; + char entity_pool_str5478[sizeof("afr")]; + char entity_pool_str5482[sizeof("DiacriticalTilde")]; + char entity_pool_str5489[sizeof("LeftDownVector")]; + char entity_pool_str5492[sizeof("LeftDownVectorBar")]; + char entity_pool_str5501[sizeof("lEg")]; + char entity_pool_str5509[sizeof("ApplyFunction")]; + char entity_pool_str5512[sizeof("bumpE")]; + char entity_pool_str5524[sizeof("Lcedil")]; + char entity_pool_str5528[sizeof("caret")]; + char entity_pool_str5530[sizeof("Barv")]; + char entity_pool_str5543[sizeof("Ccedil")]; + char entity_pool_str5547[sizeof("circledR")]; + char entity_pool_str5548[sizeof("LeftDownTeeVector")]; + char entity_pool_str5552[sizeof("tshcy")]; + char entity_pool_str5556[sizeof("DotEqual")]; + char entity_pool_str5564[sizeof("centerdot")]; + char entity_pool_str5566[sizeof("ntrianglelefteq")]; + char entity_pool_str5568[sizeof("minus")]; + char entity_pool_str5570[sizeof("gimel")]; + char entity_pool_str5577[sizeof("Aacute")]; + char entity_pool_str5578[sizeof("gtcir")]; + char entity_pool_str5583[sizeof("gtrarr")]; + char entity_pool_str5584[sizeof("bull")]; + char entity_pool_str5587[sizeof("DownArrow")]; + char entity_pool_str5593[sizeof("rdquor")]; + char entity_pool_str5595[sizeof("ldquor")]; + char entity_pool_str5598[sizeof("intlarhk")]; + char entity_pool_str5602[sizeof("utilde")]; + char entity_pool_str5612[sizeof("gacute")]; + char entity_pool_str5614[sizeof("ntilde")]; + char entity_pool_str5615[sizeof("af")]; + char entity_pool_str5618[sizeof("Hstrok")]; + char entity_pool_str5620[sizeof("exponentiale")]; + char entity_pool_str5621[sizeof("minusb")]; + char entity_pool_str5625[sizeof("RightUpTeeVector")]; + char entity_pool_str5630[sizeof("UpTeeArrow")]; + char entity_pool_str5639[sizeof("zeta")]; + char entity_pool_str5644[sizeof("DiacriticalDot")]; + char entity_pool_str5645[sizeof("DiacriticalDoubleAcute")]; + char entity_pool_str5663[sizeof("nleftarrow")]; + char entity_pool_str5664[sizeof("hkswarow")]; + char entity_pool_str5666[sizeof("iiota")]; + char entity_pool_str5669[sizeof("apacir")]; + char entity_pool_str5673[sizeof("Ncedil")]; + char entity_pool_str5678[sizeof("capand")]; + char entity_pool_str5686[sizeof("mdash")]; + char entity_pool_str5689[sizeof("filig")]; + char entity_pool_str5690[sizeof("scnsim")]; + char entity_pool_str5699[sizeof("realpart")]; + char entity_pool_str5703[sizeof("leftthreetimes")]; + char entity_pool_str5704[sizeof("asymp")]; + char entity_pool_str5718[sizeof("hellip")]; + char entity_pool_str5722[sizeof("dtrif")]; + char entity_pool_str5724[sizeof("NotExists")]; + char entity_pool_str5728[sizeof("sccue")]; + char entity_pool_str5733[sizeof("YAcy")]; + char entity_pool_str5734[sizeof("Utilde")]; + char entity_pool_str5741[sizeof("NotEqual")]; + char entity_pool_str5747[sizeof("ThinSpace")]; + char entity_pool_str5754[sizeof("apE")]; + char entity_pool_str5762[sizeof("bullet")]; + char entity_pool_str5765[sizeof("CloseCurlyDoubleQuote")]; + char entity_pool_str5766[sizeof("Delta")]; + char entity_pool_str5776[sizeof("gg")]; + char entity_pool_str5780[sizeof("otimes")]; + char entity_pool_str5799[sizeof("wreath")]; + char entity_pool_str5801[sizeof("Rcedil")]; + char entity_pool_str5807[sizeof("eth")]; + char entity_pool_str5808[sizeof("supnE")]; + char entity_pool_str5811[sizeof("awint")]; + char entity_pool_str5817[sizeof("Breve")]; + char entity_pool_str5822[sizeof("Gg")]; + char entity_pool_str5824[sizeof("HumpEqual")]; + char entity_pool_str5837[sizeof("Lleftarrow")]; + char entity_pool_str5838[sizeof("boxdr")]; + char entity_pool_str5847[sizeof("succneqq")]; + char entity_pool_str5848[sizeof("uring")]; + char entity_pool_str5849[sizeof("LessSlantEqual")]; + char entity_pool_str5860[sizeof("nvdash")]; + char entity_pool_str5866[sizeof("Hacek")]; + char entity_pool_str5867[sizeof("itilde")]; + char entity_pool_str5870[sizeof("Iota")]; + char entity_pool_str5872[sizeof("IOcy")]; + char entity_pool_str5884[sizeof("boxDr")]; + char entity_pool_str5891[sizeof("SucceedsTilde")]; + char entity_pool_str5905[sizeof("LeftFloor")]; + char entity_pool_str5906[sizeof("Vvdash")]; + char entity_pool_str5923[sizeof("triangledown")]; + char entity_pool_str5927[sizeof("LongLeftRightArrow")]; + char entity_pool_str5928[sizeof("RightFloor")]; + char entity_pool_str5931[sizeof("DownRightTeeVector")]; + char entity_pool_str5933[sizeof("quatint")]; + char entity_pool_str5937[sizeof("Ntilde")]; + char entity_pool_str5940[sizeof("Bumpeq")]; + char entity_pool_str5949[sizeof("gvnE")]; + char entity_pool_str5951[sizeof("boxhu")]; + char entity_pool_str5956[sizeof("gtlPar")]; + char entity_pool_str5959[sizeof("nprec")]; + char entity_pool_str5962[sizeof("ouml")]; + char entity_pool_str5970[sizeof("gescc")]; + char entity_pool_str5976[sizeof("Euml")]; + char entity_pool_str5980[sizeof("Uring")]; + char entity_pool_str5982[sizeof("UnderBracket")]; + char entity_pool_str5983[sizeof("nLtv")]; + char entity_pool_str5984[sizeof("LeftArrowBar")]; + char entity_pool_str5985[sizeof("ncongdot")]; + char entity_pool_str6003[sizeof("asympeq")]; + char entity_pool_str6023[sizeof("minusdu")]; + char entity_pool_str6030[sizeof("delta")]; + char entity_pool_str6032[sizeof("harrw")]; + char entity_pool_str6038[sizeof("andslope")]; + char entity_pool_str6043[sizeof("cdot")]; + char entity_pool_str6048[sizeof("Cayleys")]; + char entity_pool_str6049[sizeof("boxhU")]; + char entity_pool_str6052[sizeof("succsim")]; + char entity_pool_str6061[sizeof("cirE")]; + char entity_pool_str6062[sizeof("sdotb")]; + char entity_pool_str6066[sizeof("odash")]; + char entity_pool_str6067[sizeof("cirmid")]; + char entity_pool_str6068[sizeof("suphsub")]; + char entity_pool_str6069[sizeof("supdsub")]; + char entity_pool_str6077[sizeof("supdot")]; + char entity_pool_str6079[sizeof("awconint")]; + char entity_pool_str6084[sizeof("TSHcy")]; + char entity_pool_str6087[sizeof("grave")]; + char entity_pool_str6101[sizeof("lsimg")]; + char entity_pool_str6106[sizeof("UpArrowDownArrow")]; + char entity_pool_str6121[sizeof("LeftVector")]; + char entity_pool_str6122[sizeof("DoubleRightArrow")]; + char entity_pool_str6129[sizeof("NegativeThinSpace")]; + char entity_pool_str6140[sizeof("lhblk")]; + char entity_pool_str6146[sizeof("cire")]; + char entity_pool_str6147[sizeof("nVDash")]; + char entity_pool_str6151[sizeof("uhblk")]; + char entity_pool_str6155[sizeof("imagpart")]; + char entity_pool_str6161[sizeof("RightUpDownVector")]; + char entity_pool_str6164[sizeof("boxdL")]; + char entity_pool_str6176[sizeof("gla")]; + char entity_pool_str6193[sizeof("Iuml")]; + char entity_pool_str6203[sizeof("oelig")]; + char entity_pool_str6208[sizeof("NotLessSlantEqual")]; + char entity_pool_str6210[sizeof("boxDL")]; + char entity_pool_str6215[sizeof("gamma")]; + char entity_pool_str6236[sizeof("Otimes")]; + char entity_pool_str6248[sizeof("longleftrightarrow")]; + char entity_pool_str6261[sizeof("Gamma")]; + char entity_pool_str6262[sizeof("bigwedge")]; + char entity_pool_str6268[sizeof("boxhd")]; + char entity_pool_str6283[sizeof("supE")]; + char entity_pool_str6292[sizeof("LeftUpTeeVector")]; + char entity_pool_str6298[sizeof("gesdoto")]; + char entity_pool_str6304[sizeof("kappa")]; + char entity_pool_str6315[sizeof("ngeqslant")]; + char entity_pool_str6340[sizeof("gtrless")]; + char entity_pool_str6351[sizeof("fflig")]; + char entity_pool_str6352[sizeof("bigsqcup")]; + char entity_pool_str6367[sizeof("kgreen")]; + char entity_pool_str6368[sizeof("supe")]; + char entity_pool_str6370[sizeof("boxtimes")]; + char entity_pool_str6386[sizeof("gnapprox")]; + char entity_pool_str6394[sizeof("downdownarrows")]; + char entity_pool_str6403[sizeof("biguplus")]; + char entity_pool_str6404[sizeof("khcy")]; + char entity_pool_str6406[sizeof("ddagger")]; + char entity_pool_str6418[sizeof("Ouml")]; + char entity_pool_str6420[sizeof("Beta")]; + char entity_pool_str6421[sizeof("minusd")]; + char entity_pool_str6422[sizeof("succnsim")]; + char entity_pool_str6424[sizeof("ctdot")]; + char entity_pool_str6427[sizeof("kjcy")]; + char entity_pool_str6428[sizeof("gjcy")]; + char entity_pool_str6430[sizeof("ncong")]; + char entity_pool_str6431[sizeof("xvee")]; + char entity_pool_str6432[sizeof("bcong")]; + char entity_pool_str6439[sizeof("sqsube")]; + char entity_pool_str6442[sizeof("boxdR")]; + char entity_pool_str6445[sizeof("Longleftrightarrow")]; + char entity_pool_str6447[sizeof("sqsub")]; + char entity_pool_str6451[sizeof("DownLeftRightVector")]; + char entity_pool_str6454[sizeof("sqsubset")]; + char entity_pool_str6456[sizeof("NotVerticalBar")]; + char entity_pool_str6461[sizeof("NotEqualTilde")]; + char entity_pool_str6485[sizeof("boxdl")]; + char entity_pool_str6488[sizeof("boxDR")]; + char entity_pool_str6490[sizeof("andand")]; + char entity_pool_str6502[sizeof("RightVector")]; + char entity_pool_str6504[sizeof("IJlig")]; + char entity_pool_str6505[sizeof("NotTildeEqual")]; + char entity_pool_str6509[sizeof("angzarr")]; + char entity_pool_str6515[sizeof("angrt")]; + char entity_pool_str6521[sizeof("acd")]; + char entity_pool_str6524[sizeof("andd")]; + char entity_pool_str6526[sizeof("nrarrc")]; + char entity_pool_str6527[sizeof("VeryThinSpace")]; + char entity_pool_str6529[sizeof("Superset")]; + char entity_pool_str6531[sizeof("boxDl")]; + char entity_pool_str6535[sizeof("vnsub")]; + char entity_pool_str6538[sizeof("ccupssm")]; + char entity_pool_str6548[sizeof("varnothing")]; + char entity_pool_str6552[sizeof("rcy")]; + char entity_pool_str6554[sizeof("lcy")]; + char entity_pool_str6556[sizeof("scy")]; + char entity_pool_str6558[sizeof("Tcy")]; + char entity_pool_str6559[sizeof("Zcy")]; + char entity_pool_str6560[sizeof("ecy")]; + char entity_pool_str6561[sizeof("rdsh")]; + char entity_pool_str6563[sizeof("ldsh")]; + char entity_pool_str6565[sizeof("ucy")]; + char entity_pool_str6566[sizeof("boxVH")]; + char entity_pool_str6567[sizeof("tcy")]; + char entity_pool_str6577[sizeof("ncy")]; + char entity_pool_str6579[sizeof("bcy")]; + char entity_pool_str6580[sizeof("ntgl")]; + char entity_pool_str6585[sizeof("Jcy")]; + char entity_pool_str6600[sizeof("congdot")]; + char entity_pool_str6607[sizeof("angst")]; + char entity_pool_str6609[sizeof("RightDownTeeVector")]; + char entity_pool_str6612[sizeof("OverParenthesis")]; + char entity_pool_str6613[sizeof("ltquest")]; + char entity_pool_str6615[sizeof("pcy")]; + char entity_pool_str6618[sizeof("otilde")]; + char entity_pool_str6619[sizeof("rdquo")]; + char entity_pool_str6621[sizeof("ldquo")]; + char entity_pool_str6623[sizeof("Vcy")]; + char entity_pool_str6626[sizeof("capbrcup")]; + char entity_pool_str6646[sizeof("bdquo")]; + char entity_pool_str6650[sizeof("DownArrowBar")]; + char entity_pool_str6657[sizeof("vcy")]; + char entity_pool_str6665[sizeof("angrtvb")]; + char entity_pool_str6676[sizeof("Kcy")]; + char entity_pool_str6683[sizeof("Mcy")]; + char entity_pool_str6684[sizeof("Scy")]; + char entity_pool_str6691[sizeof("NewLine")]; + char entity_pool_str6696[sizeof("fcy")]; + char entity_pool_str6697[sizeof("Ucy")]; + char entity_pool_str6704[sizeof("boxVh")]; + char entity_pool_str6715[sizeof("Dcy")]; + char entity_pool_str6738[sizeof("hstrok")]; + char entity_pool_str6751[sizeof("Lcy")]; + char entity_pool_str6762[sizeof("Ycy")]; + char entity_pool_str6775[sizeof("supsim")]; + char entity_pool_str6789[sizeof("NonBreakingSpace")]; + char entity_pool_str6790[sizeof("OverBar")]; + char entity_pool_str6791[sizeof("sqsubseteq")]; + char entity_pool_str6797[sizeof("GJcy")]; + char entity_pool_str6800[sizeof("OverBrace")]; + char entity_pool_str6806[sizeof("eqcirc")]; + char entity_pool_str6819[sizeof("OverBracket")]; + char entity_pool_str6821[sizeof("Auml")]; + char entity_pool_str6829[sizeof("acute")]; + char entity_pool_str6830[sizeof("icy")]; + char entity_pool_str6849[sizeof("Itilde")]; + char entity_pool_str6850[sizeof("HilbertSpace")]; + char entity_pool_str6854[sizeof("omega")]; + char entity_pool_str6855[sizeof("cacute")]; + char entity_pool_str6861[sizeof("scirc")]; + char entity_pool_str6865[sizeof("ecirc")]; + char entity_pool_str6870[sizeof("ucirc")]; + char entity_pool_str6872[sizeof("GreaterSlantEqual")]; + char entity_pool_str6890[sizeof("Jcirc")]; + char entity_pool_str6895[sizeof("nvDash")]; + char entity_pool_str6896[sizeof("Wcirc")]; + char entity_pool_str6900[sizeof("Ncy")]; + char entity_pool_str6921[sizeof("RightTeeArrow")]; + char entity_pool_str6942[sizeof("LessFullEqual")]; + char entity_pool_str6958[sizeof("ltcc")]; + char entity_pool_str6963[sizeof("aleph")]; + char entity_pool_str6979[sizeof("dcy")]; + char entity_pool_str6989[sizeof("Scirc")]; + char entity_pool_str6991[sizeof("lessapprox")]; + char entity_pool_str7000[sizeof("IEcy")]; + char entity_pool_str7001[sizeof("LowerRightArrow")]; + char entity_pool_str7002[sizeof("Ucirc")]; + char entity_pool_str7021[sizeof("agrave")]; + char entity_pool_str7023[sizeof("MinusPlus")]; + char entity_pool_str7024[sizeof("bigvee")]; + char entity_pool_str7028[sizeof("Rcy")]; + char entity_pool_str7034[sizeof("suphsol")]; + char entity_pool_str7037[sizeof("EmptyVerySmallSquare")]; + char entity_pool_str7039[sizeof("boxhD")]; + char entity_pool_str7047[sizeof("precapprox")]; + char entity_pool_str7066[sizeof("angrtvbd")]; + char entity_pool_str7067[sizeof("Ycirc")]; + char entity_pool_str7071[sizeof("sub")]; + char entity_pool_str7074[sizeof("Otilde")]; + char entity_pool_str7075[sizeof("Ccirc")]; + char entity_pool_str7085[sizeof("Fcy")]; + char entity_pool_str7090[sizeof("complexes")]; + char entity_pool_str7096[sizeof("subrarr")]; + char entity_pool_str7115[sizeof("InvisibleComma")]; + char entity_pool_str7120[sizeof("boxur")]; + char entity_pool_str7121[sizeof("abreve")]; + char entity_pool_str7127[sizeof("ntlg")]; + char entity_pool_str7135[sizeof("icirc")]; + char entity_pool_str7142[sizeof("xdtri")]; + char entity_pool_str7143[sizeof("circ")]; + char entity_pool_str7168[sizeof("gtrdot")]; + char entity_pool_str7171[sizeof("geqslant")]; + char entity_pool_str7183[sizeof("ntriangleright")]; + char entity_pool_str7198[sizeof("cuepr")]; + char entity_pool_str7199[sizeof("Sub")]; + char entity_pool_str7201[sizeof("mcy")]; + char entity_pool_str7212[sizeof("timesbar")]; + char entity_pool_str7214[sizeof("hksearow")]; + char entity_pool_str7217[sizeof("sigma")]; + char entity_pool_str7224[sizeof("cupor")]; + char entity_pool_str7230[sizeof("oslash")]; + char entity_pool_str7231[sizeof("dzigrarr")]; + char entity_pool_str7234[sizeof("leftrightharpoons")]; + char entity_pool_str7245[sizeof("rightleftharpoons")]; + char entity_pool_str7247[sizeof("kcedil")]; + char entity_pool_str7256[sizeof("submult")]; + char entity_pool_str7260[sizeof("curren")]; + char entity_pool_str7269[sizeof("LeftTeeVector")]; + char entity_pool_str7274[sizeof("bigstar")]; + char entity_pool_str7277[sizeof("cup")]; + char entity_pool_str7278[sizeof("LongRightArrow")]; + char entity_pool_str7294[sizeof("Gcedil")]; + char entity_pool_str7296[sizeof("PrecedesEqual")]; + char entity_pool_str7307[sizeof("zcy")]; + char entity_pool_str7309[sizeof("planckh")]; + char entity_pool_str7310[sizeof("Omega")]; + char entity_pool_str7317[sizeof("subsub")]; + char entity_pool_str7325[sizeof("rdca")]; + char entity_pool_str7326[sizeof("cups")]; + char entity_pool_str7327[sizeof("ldca")]; + char entity_pool_str7332[sizeof("subset")]; + char entity_pool_str7333[sizeof("NotSucceeds")]; + char entity_pool_str7334[sizeof("LeftArrowRightArrow")]; + char entity_pool_str7337[sizeof("wcirc")]; + char entity_pool_str7338[sizeof("RightAngleBracket")]; + char entity_pool_str7344[sizeof("ntrianglerighteq")]; + char entity_pool_str7345[sizeof("Sigma")]; + char entity_pool_str7350[sizeof("NotSucceedsTilde")]; + char entity_pool_str7364[sizeof("DiacriticalAcute")]; + char entity_pool_str7376[sizeof("subne")]; + char entity_pool_str7378[sizeof("Product")]; + char entity_pool_str7385[sizeof("circleddash")]; + char entity_pool_str7389[sizeof("subsup")]; + char entity_pool_str7397[sizeof("copy")]; + char entity_pool_str7403[sizeof("eta")]; + char entity_pool_str7409[sizeof("angmsd")]; + char entity_pool_str7434[sizeof("natural")]; + char entity_pool_str7436[sizeof("supedot")]; + char entity_pool_str7437[sizeof("naturals")]; + char entity_pool_str7443[sizeof("triangleright")]; + char entity_pool_str7445[sizeof("DiacriticalGrave")]; + char entity_pool_str7446[sizeof("boxuL")]; + char entity_pool_str7447[sizeof("cong")]; + char entity_pool_str7451[sizeof("telrec")]; + char entity_pool_str7454[sizeof("comma")]; + char entity_pool_str7460[sizeof("Subset")]; + char entity_pool_str7475[sizeof("NotSucceedsSlantEqual")]; + char entity_pool_str7476[sizeof("gtreqless")]; + char entity_pool_str7477[sizeof("Atilde")]; + char entity_pool_str7484[sizeof("curarr")]; + char entity_pool_str7491[sizeof("cudarrr")]; + char entity_pool_str7495[sizeof("cudarrl")]; + char entity_pool_str7503[sizeof("subseteq")]; + char entity_pool_str7504[sizeof("subseteqq")]; + char entity_pool_str7505[sizeof("rightsquigarrow")]; + char entity_pool_str7520[sizeof("cupcap")]; + char entity_pool_str7521[sizeof("subsetneq")]; + char entity_pool_str7532[sizeof("aogon")]; + char entity_pool_str7533[sizeof("notinvc")]; + char entity_pool_str7534[sizeof("rightthreetimes")]; + char entity_pool_str7552[sizeof("yacute")]; + char entity_pool_str7563[sizeof("nLeftarrow")]; + char entity_pool_str7581[sizeof("ocy")]; + char entity_pool_str7582[sizeof("cemptyv")]; + char entity_pool_str7595[sizeof("Ecy")]; + char entity_pool_str7598[sizeof("cupcup")]; + char entity_pool_str7604[sizeof("trianglerighteq")]; + char entity_pool_str7615[sizeof("LeftRightArrow")]; + char entity_pool_str7618[sizeof("succ")]; + char entity_pool_str7631[sizeof("DownArrowUpArrow")]; + char entity_pool_str7641[sizeof("OElig")]; + char entity_pool_str7648[sizeof("chcy")]; + char entity_pool_str7649[sizeof("gtreqqless")]; + char entity_pool_str7655[sizeof("angle")]; + char entity_pool_str7662[sizeof("acE")]; + char entity_pool_str7668[sizeof("rmoustache")]; + char entity_pool_str7670[sizeof("lmoustache")]; + char entity_pool_str7674[sizeof("NegativeVeryThinSpace")]; + char entity_pool_str7677[sizeof("napprox")]; + char entity_pool_str7686[sizeof("Oslash")]; + char entity_pool_str7698[sizeof("subsetneqq")]; + char entity_pool_str7723[sizeof("Aring")]; + char entity_pool_str7724[sizeof("boxuR")]; + char entity_pool_str7730[sizeof("subplus")]; + char entity_pool_str7742[sizeof("xwedge")]; + char entity_pool_str7767[sizeof("boxul")]; + char entity_pool_str7778[sizeof("boxvr")]; + char entity_pool_str7800[sizeof("HumpDownHump")]; + char entity_pool_str7812[sizeof("Icy")]; + char entity_pool_str7828[sizeof("approxeq")]; + char entity_pool_str7841[sizeof("aacute")]; + char entity_pool_str7842[sizeof("apid")]; + char entity_pool_str7859[sizeof("UpDownArrow")]; + char entity_pool_str7861[sizeof("NestedGreaterGreater")]; + char entity_pool_str7863[sizeof("jcy")]; + char entity_pool_str7866[sizeof("gtrsim")]; + char entity_pool_str7876[sizeof("boxv")]; + char entity_pool_str7886[sizeof("ocirc")]; + char entity_pool_str7900[sizeof("Ecirc")]; + char entity_pool_str7987[sizeof("notnivc")]; + char entity_pool_str8006[sizeof("bigtriangleup")]; + char entity_pool_str8032[sizeof("daleth")]; + char entity_pool_str8037[sizeof("Ocy")]; + char entity_pool_str8042[sizeof("Hcirc")]; + char entity_pool_str8043[sizeof("RightVectorBar")]; + char entity_pool_str8044[sizeof("AElig")]; + char entity_pool_str8063[sizeof("FilledVerySmallSquare")]; + char entity_pool_str8084[sizeof("ggg")]; + char entity_pool_str8088[sizeof("Bcy")]; + char entity_pool_str8099[sizeof("Poincareplane")]; + char entity_pool_str8104[sizeof("boxvL")]; + char entity_pool_str8107[sizeof("PartialD")]; + char entity_pool_str8117[sizeof("Icirc")]; + char entity_pool_str8129[sizeof("cularr")]; + char entity_pool_str8135[sizeof("boxh")]; + char entity_pool_str8142[sizeof("andv")]; + char entity_pool_str8144[sizeof("sung")]; + char entity_pool_str8148[sizeof("RightDoubleBracket")]; + char entity_pool_str8168[sizeof("jcirc")]; + char entity_pool_str8174[sizeof("UnderBar")]; + char entity_pool_str8241[sizeof("RightArrow")]; + char entity_pool_str8242[sizeof("circledcirc")]; + char entity_pool_str8243[sizeof("Alpha")]; + char entity_pool_str8251[sizeof("leftharpoonup")]; + char entity_pool_str8258[sizeof("cularrp")]; + char entity_pool_str8260[sizeof("RightArrowLeftArrow")]; + char entity_pool_str8281[sizeof("varsigma")]; + char entity_pool_str8300[sizeof("numero")]; + char entity_pool_str8310[sizeof("ffllig")]; + char entity_pool_str8326[sizeof("LowerLeftArrow")]; + char entity_pool_str8340[sizeof("expectation")]; + char entity_pool_str8342[sizeof("Ocirc")]; + char entity_pool_str8351[sizeof("yacy")]; + char entity_pool_str8375[sizeof("lambda")]; + char entity_pool_str8381[sizeof("NotSucceedsEqual")]; + char entity_pool_str8382[sizeof("boxvR")]; + char entity_pool_str8384[sizeof("bigtriangledown")]; + char entity_pool_str8391[sizeof("ang")]; + char entity_pool_str8404[sizeof("xuplus")]; + char entity_pool_str8424[sizeof("nabla")]; + char entity_pool_str8425[sizeof("boxvl")]; + char entity_pool_str8438[sizeof("Eta")]; + char entity_pool_str8440[sizeof("Acy")]; + char entity_pool_str8474[sizeof("kcy")]; + char entity_pool_str8475[sizeof("gcy")]; + char entity_pool_str8485[sizeof("LeftRightVector")]; + char entity_pool_str8491[sizeof("ccedil")]; + char entity_pool_str8495[sizeof("Backslash")]; + char entity_pool_str8506[sizeof("hslash")]; + char entity_pool_str8515[sizeof("Pcy")]; + char entity_pool_str8521[sizeof("Gcy")]; + char entity_pool_str8534[sizeof("gtquest")]; + char entity_pool_str8572[sizeof("Lambda")]; + char entity_pool_str8627[sizeof("odiv")]; + char entity_pool_str8629[sizeof("leftharpoondown")]; + char entity_pool_str8672[sizeof("longmapsto")]; + char entity_pool_str8677[sizeof("Jukcy")]; + char entity_pool_str8687[sizeof("ldrdhar")]; + char entity_pool_str8700[sizeof("xutri")]; + char entity_pool_str8701[sizeof("nRightarrow")]; + char entity_pool_str8725[sizeof("ExponentialE")]; + char entity_pool_str8735[sizeof("nrightarrow")]; + char entity_pool_str8745[sizeof("Acirc")]; + char entity_pool_str8746[sizeof("NoBreak")]; + char entity_pool_str8780[sizeof("gcirc")]; + char entity_pool_str8784[sizeof("ange")]; + char entity_pool_str8785[sizeof("curarrm")]; + char entity_pool_str8791[sizeof("SHCHcy")]; + char entity_pool_str8796[sizeof("yuml")]; + char entity_pool_str8800[sizeof("subnE")]; + char entity_pool_str8803[sizeof("DDotrahd")]; + char entity_pool_str8810[sizeof("RuleDelayed")]; + char entity_pool_str8826[sizeof("Gcirc")]; + char entity_pool_str8843[sizeof("Jsercy")]; + char entity_pool_str8879[sizeof("gtcc")]; + char entity_pool_str8922[sizeof("iukcy")]; + char entity_pool_str8956[sizeof("updownarrow")]; + char entity_pool_str8962[sizeof("curlyvee")]; + char entity_pool_str8972[sizeof("ffilig")]; + char entity_pool_str8992[sizeof("yicy")]; + char entity_pool_str9015[sizeof("divonx")]; + char entity_pool_str9026[sizeof("gtrapprox")]; + char entity_pool_str9069[sizeof("subdot")]; + char entity_pool_str9079[sizeof("leftrightarrows")]; + char entity_pool_str9085[sizeof("auml")]; + char entity_pool_str9088[sizeof("Updownarrow")]; + char entity_pool_str9090[sizeof("rightleftarrows")]; + char entity_pool_str9151[sizeof("DownRightVector")]; + char entity_pool_str9154[sizeof("DownRightVectorBar")]; + char entity_pool_str9162[sizeof("hcirc")]; + char entity_pool_str9186[sizeof("Rrightarrow")]; + char entity_pool_str9217[sizeof("longrightarrow")]; + char entity_pool_str9239[sizeof("cupdot")]; + char entity_pool_str9249[sizeof("ac")]; + char entity_pool_str9268[sizeof("hookrightarrow")]; + char entity_pool_str9271[sizeof("NegativeThickSpace")]; + char entity_pool_str9275[sizeof("subE")]; + char entity_pool_str9307[sizeof("twoheadrightarrow")]; + char entity_pool_str9320[sizeof("downharpoonright")]; + char entity_pool_str9321[sizeof("downharpoonleft")]; + char entity_pool_str9326[sizeof("aelig")]; + char entity_pool_str9330[sizeof("rdldhar")]; + char entity_pool_str9349[sizeof("curlywedge")]; + char entity_pool_str9351[sizeof("hybull")]; + char entity_pool_str9360[sizeof("sube")]; + char entity_pool_str9414[sizeof("Longrightarrow")]; + char entity_pool_str9484[sizeof("Cedilla")]; + char entity_pool_str9505[sizeof("notinva")]; + char entity_pool_str9506[sizeof("SucceedsEqual")]; + char entity_pool_str9554[sizeof("leftrightarrow")]; + char entity_pool_str9580[sizeof("straightepsilon")]; + char entity_pool_str9627[sizeof("amalg")]; + char entity_pool_str9741[sizeof("atilde")]; + char entity_pool_str9747[sizeof("RightCeiling")]; + char entity_pool_str9751[sizeof("Leftrightarrow")]; + char entity_pool_str9767[sizeof("subsim")]; + char entity_pool_str9788[sizeof("VerticalLine")]; + char entity_pool_str9801[sizeof("RightUpVector")]; + char entity_pool_str9804[sizeof("RightUpVectorBar")]; + char entity_pool_str9829[sizeof("RightDownVector")]; + char entity_pool_str9832[sizeof("RightDownVectorBar")]; + char entity_pool_str9836[sizeof("alefsym")]; + char entity_pool_str9852[sizeof("circlearrowright")]; + char entity_pool_str9853[sizeof("circlearrowleft")]; + char entity_pool_str9904[sizeof("Iukcy")]; + char entity_pool_str9936[sizeof("otimesas")]; + char entity_pool_str9944[sizeof("intercal")]; + char entity_pool_str9952[sizeof("thickapprox")]; + char entity_pool_str9955[sizeof("jukcy")]; + char entity_pool_str9959[sizeof("notniva")]; + char entity_pool_str9963[sizeof("precnapprox")]; + char entity_pool_str9983[sizeof("cuvee")]; + char entity_pool_str9987[sizeof("aring")]; + char entity_pool_str10023[sizeof("ccirc")]; + char entity_pool_str10029[sizeof("rightarrow")]; + char entity_pool_str10061[sizeof("Integral")]; + char entity_pool_str10062[sizeof("xcirc")]; + char entity_pool_str10121[sizeof("jsercy")]; + char entity_pool_str10206[sizeof("checkmark")]; + char entity_pool_str10208[sizeof("VerticalTilde")]; + char entity_pool_str10219[sizeof("boxvH")]; + char entity_pool_str10240[sizeof("NotRightTriangleBar")]; + char entity_pool_str10244[sizeof("NotRightTriangleEqual")]; + char entity_pool_str10245[sizeof("NotRightTriangle")]; + char entity_pool_str10278[sizeof("LeftVectorBar")]; + char entity_pool_str10357[sizeof("boxvh")]; + char entity_pool_str10395[sizeof("boxbox")]; + char entity_pool_str10415[sizeof("ycy")]; + char entity_pool_str10428[sizeof("subedot")]; + char entity_pool_str10445[sizeof("SOFTcy")]; + char entity_pool_str10505[sizeof("Rightarrow")]; + char entity_pool_str10507[sizeof("alpha")]; + char entity_pool_str10528[sizeof("shchcy")]; + char entity_pool_str10584[sizeof("softcy")]; + char entity_pool_str10704[sizeof("acy")]; + char entity_pool_str10720[sizeof("ycirc")]; + char entity_pool_str10791[sizeof("bigcirc")]; + char entity_pool_str10808[sizeof("ImaginaryI")]; + char entity_pool_str10847[sizeof("approx")]; + char entity_pool_str10851[sizeof("SupersetEqual")]; + char entity_pool_str10879[sizeof("vzigzag")]; + char entity_pool_str10888[sizeof("cuesc")]; + char entity_pool_str10947[sizeof("UnderParenthesis")]; + char entity_pool_str11009[sizeof("acirc")]; + char entity_pool_str11029[sizeof("succapprox")]; + char entity_pool_str11047[sizeof("mcomma")]; + char entity_pool_str11146[sizeof("angmsdae")]; + char entity_pool_str11165[sizeof("angmsdab")]; + char entity_pool_str11282[sizeof("angmsdaf")]; + char entity_pool_str11366[sizeof("angsph")]; + char entity_pool_str11527[sizeof("luruhar")]; + char entity_pool_str11565[sizeof("angmsdad")]; + char entity_pool_str11664[sizeof("twoheadleftarrow")]; + char entity_pool_str11720[sizeof("cylcty")]; + char entity_pool_str11791[sizeof("straightphi")]; + char entity_pool_str11840[sizeof("multimap")]; + char entity_pool_str11918[sizeof("RightArrowBar")]; + char entity_pool_str12012[sizeof("ldrushar")]; + char entity_pool_str12103[sizeof("LeftAngleBracket")]; + char entity_pool_str12170[sizeof("ruluhar")]; + char entity_pool_str12202[sizeof("curlyeqprec")]; + char entity_pool_str12206[sizeof("yucy")]; + char entity_pool_str12288[sizeof("lurdshar")]; + char entity_pool_str12413[sizeof("hardcy")]; + char entity_pool_str12461[sizeof("rightharpoondown")]; + char entity_pool_str12497[sizeof("rightharpoonup")]; + char entity_pool_str12502[sizeof("HARDcy")]; + char entity_pool_str12651[sizeof("SubsetEqual")]; + char entity_pool_str12809[sizeof("digamma")]; + char entity_pool_str12892[sizeof("udblac")]; + char entity_pool_str12985[sizeof("SuchThat")]; + char entity_pool_str12991[sizeof("cuwed")]; + char entity_pool_str13024[sizeof("Udblac")]; + char entity_pool_str13061[sizeof("angmsdag")]; + char entity_pool_str13443[sizeof("angmsdah")]; + char entity_pool_str13643[sizeof("VerticalBar")]; + char entity_pool_str13659[sizeof("VerticalSeparator")]; + char entity_pool_str13709[sizeof("rightarrowtail")]; + char entity_pool_str13908[sizeof("odblac")]; + char entity_pool_str13945[sizeof("succnapprox")]; + char entity_pool_str14304[sizeof("angmsdac")]; + char entity_pool_str14364[sizeof("Odblac")]; + char entity_pool_str14620[sizeof("cupbrcap")]; + char entity_pool_str15290[sizeof("angmsdaa")]; + char entity_pool_str15360[sizeof("curlyeqsucc")]; + char entity_pool_str15729[sizeof("curvearrowleft")]; + char entity_pool_str16000[sizeof("curvearrowright")]; + }; +static const struct entity_pool_t entity_pool_contents = + { + "rarr", + "larr", + "lat", + "uarr", + "npr", + "rarrtl", + "larrtl", + "roarr", + "loarr", + "not", + "rpar", + "bot", + "lpar", + "spar", + "ll", + "uharr", + "epar", + "el", + "rotimes", + "lotimes", + "par", + "nharr", + "npar", + "tprime", + "els", + "eparsl", + "ensp", + "bprime", + "lnap", + "blk14", + "blk12", + "blk34", + "nparsl", + "nldr", + "rlarr", + "npart", + "llarr", + "nlt", + "slarr", + "nparallel", + "Tau", + "varr", + "squ", + "nlarr", + "tau", + "lne", + "rrarr", + "lrarr", + "srarr", + "rharul", + "lharul", + "erarr", + "pr", + "rharu", + "lharu", + "Uarr", + "nGt", + "bne", + "nrarr", + "swarr", + "rarrap", + "upuparrows", + "Darr", + "rbarr", + "Dot", + "lbarr", + "nwarr", + "smt", + "emsp14", + "rarrpl", + "larrpl", + "phmmat", + "emsp13", + "LT", + "Larr", + "rbrkslu", + "lbrkslu", + "napos", + "nle", + "rHar", + "lHar", + "qprime", + "lap", + "nbsp", + "uHar", + "top", + "Vbar", + "Ll", + "prap", + "emsp", + "nap", + "looparrowleft", + "le", + "sharp", + "ee", + "les", + "in", + "prop", + "topbot", + "int", + "ne", + "nprcue", + "pre", + "epsi", + "upsi", + "there4", + "rbrke", + "searr", + "lbrke", + "blacktriangle", + "lneq", + "lneqq", + "plus", + "nles", + "nedot", + "blacktriangleleft", + "blacktriangleright", + "nearr", + "blacktriangledown", + "nless", + "emacr", + "vprop", + "umacr", + "smeparsl", + "Map", + "plusdu", + "Not", + "Verbar", + "perp", + "fltns", + "plusmn", + "nleq", + "nleqq", + "frac34", + "frac14", + "verbar", + "frac12", + "frac35", + "frac15", + "frac45", + "frac25", + "frac13", + "frac16", + "prurel", + "frac23", + "frac38", + "frac18", + "frac56", + "frac58", + "frac78", + "leq", + "darr", + "Upsi", + "dot", + "phone", + "Cap", + "blacksquare", + "rnmid", + "leqq", + "intcal", + "dharr", + "rhard", + "lhard", + "pluse", + "Umacr", + "Vee", + "Rarr", + "Cross", + "rsqb", + "lsqb", + "Rarrtl", + "esdot", + "vee", + "nbumpe", + "llcorner", + "fpartint", + "squf", + "plankv", + "eqvparsl", + "ulcorner", + "wp", + "lozf", + "COPY", + "ulcorn", + "veebar", + "part", + "square", + "nbump", + "bernou", + "wr", + "rBarr", + "lrcorner", + "lBarr", + "bnot", + "semi", + "urcorner", + "NotSubset", + "ropf", + "Qopf", + "lopf", + "sopf", + "urcorn", + "Topf", + "Zopf", + "eopf", + "ropar", + "uopf", + "lopar", + "topf", + "Xopf", + "nopf", + "bopf", + "epsiv", + "fnof", + "imacr", + "Jopf", + "nhpar", + "Wopf", + "Sqrt", + "nsub", + "napid", + "NotSuperset", + "brvbar", + "sol", + "easter", + "popf", + "dHar", + "Vopf", + "nsupset", + "nsup", + "vBar", + "nsubset", + "thkap", + "nis", + "profsurf", + "solb", + "lnsim", + "solbar", + "Square", + "vopf", + "uharl", + "ulcrop", + "eqsim", + "equiv", + "ell", + "smashp", + "mp", + "Kopf", + "simrarr", + "flat", + "Mopf", + "Sopf", + "mldr", + "rlm", + "iprod", + "lparlt", + "fopf", + "Uopf", + "varsubsetneq", + "varsubsetneqq", + "urcrop", + "LessLess", + "Re", + "NotNestedLessLess", + "Dopf", + "forkv", + "nsqsube", + "nsupe", + "nsube", + "qopf", + "rlhar", + "lrm", + "nlsim", + "pound", + "varsupsetneq", + "varsupsetneqq", + "bnequiv", + "Lopf", + "nsqsupe", + "rarrlp", + "wedbar", + "larrlp", + "Yopf", + "NotReverseElement", + "Copf", + "lrhar", + "parsl", + "uml", + "marker", + "nsupseteq", + "nsubseteq", + "squarf", + "Vert", + "SquareSupersetEqual", + "prsim", + "SquareSubsetEqual", + "SquareSuperset", + "SquareSubset", + "nvap", + "iopf", + "pm", + "vert", + "thetav", + "loz", + "map", + "lesseqqgtr", + "rscr", + "Qscr", + "lscr", + "sscr", + "Tscr", + "Zscr", + "escr", + "uscr", + "tscr", + "imof", + "Coproduct", + "Xscr", + "Xi", + "nscr", + "ni", + "bscr", + "Nopf", + "Jscr", + "preceq", + "nvrArr", + "backprime", + "Wscr", + "varphi", + "nsmid", + "dlcorn", + "pscr", + "pi", + "Vscr", + "nesim", + "simne", + "nsupseteqq", + "nsubseteqq", + "drcorn", + "rbrace", + "vscr", + "lbrace", + "dopf", + "frasl", + "LessTilde", + "Kscr", + "pluscir", + "Mscr", + "Sscr", + "rbrksld", + "lbrksld", + "RBarr", + "sqcaps", + "rArr", + "bNot", + "lArr", + "fscr", + "Uscr", + "uArr", + "Ropf", + "wopf", + "Dscr", + "opar", + "seswar", + "Del", + "rAarr", + "rho", + "lAarr", + "preccurlyeq", + "qscr", + "macr", + "notin", + "equivDD", + "sqcap", + "nspar", + "olt", + "ratio", + "Lscr", + "dharl", + "dlcrop", + "DoubleDot", + "dotplus", + "or", + "Yscr", + "Fopf", + "Cscr", + "olarr", + "nrarrw", + "lvertneqq", + "eqslantgtr", + "thorn", + "eqslantless", + "incare", + "vArr", + "rppolint", + "drcrop", + "parallel", + "orarr", + "ssmile", + "DoubleLeftTee", + "erDot", + "diams", + "ssetmn", + "oS", + "iscr", + "ii", + "rect", + "nsccue", + "sect", + "mlcp", + "oror", + "DoubleContourIntegral", + "equals", + "Hat", + "sstarf", + "mstpos", + "die", + "measuredangle", + "forall", + "notinvb", + "mopf", + "niv", + "vBarv", + "Nscr", + "period", + "becaus", + "between", + "Int", + "because", + "piv", + "rfr", + "Qfr", + "lfr", + "sfr", + "nleftrightarrow", + "Tfr", + "Zfr", + "efr", + "sim", + "ufr", + "roplus", + "tfr", + "loplus", + "Xfr", + "real", + "nfr", + "bfr", + "NotHumpEqual", + "Jfr", + "dscr", + "Wfr", + "blacklozenge", + "zopf", + "reals", + "NotCupCap", + "simplus", + "ForAll", + "pfr", + "omacr", + "Vfr", + "Emacr", + "Rscr", + "wscr", + "ShortUpArrow", + "setmn", + "vfr", + "Kfr", + "operp", + "Mfr", + "Sfr", + "nltrie", + "Fscr", + "ffr", + "Ufr", + "shortmid", + "nvsim", + "Dfr", + "lessdot", + "profline", + "qfr", + "dArr", + "nrtrie", + "ShortRightArrow", + "Therefore", + "DD", + "therefore", + "Lfr", + "target", + "Element", + "Yfr", + "ClockwiseContourIntegral", + "olcir", + "Cfr", + "female", + "nsucceq", + "oast", + "percnt", + "ordf", + "ord", + "Rho", + "mscr", + "nvrtrie", + "lnE", + "nhArr", + "Or", + "divide", + "ifr", + "elinters", + "bsol", + "nvlArr", + "Imacr", + "backsimeq", + "twixt", + "olcross", + "rarrsim", + "DoubleDownArrow", + "larrsim", + "emptyset", + "oopf", + "exist", + "llhard", + "excl", + "Eopf", + "nlArr", + "thinsp", + "NotSubsetEqual", + "phi", + "DoubleLeftArrow", + "topcir", + "div", + "Nfr", + "nlE", + "zscr", + "lrhard", + "lltri", + "nrArr", + "NotSupersetEqual", + "swArr", + "ThickSpace", + "ultri", + "notnivb", + "prime", + "primes", + "ohm", + "CircleTimes", + "nltri", + "siml", + "nwArr", + "varpi", + "orv", + "setminus", + "lrtri", + "permil", + "mid", + "urtri", + "dfr", + "mho", + "prE", + "vsupne", + "nrtri", + "vsubne", + "eDot", + "lesges", + "backepsilon", + "ratail", + "latail", + "UpEquilibrium", + "epsilon", + "upsilon", + "midast", + "Hopf", + "vltri", + "Rfr", + "Wedge", + "wfr", + "barwed", + "malt", + "Chi", + "emptyv", + "notni", + "LessGreater", + "diam", + "vrtri", + "CircleMinus", + "Omacr", + "seArr", + "Ffr", + "precneqq", + "Diamond", + "ordm", + "neArr", + "Iopf", + "CircleDot", + "prnap", + "dotminus", + "nshortmid", + "bottom", + "pointint", + "SquareUnion", + "jopf", + "Upsilon", + "Colone", + "nvlt", + "NestedLessLess", + "Colon", + "bsolhsub", + "DoubleLeftRightArrow", + "plussim", + "image", + "egs", + "oscr", + "swnwar", + "zeetrf", + "maltese", + "mfr", + "rarrfs", + "Escr", + "larrfs", + "mnplus", + "ngt", + "ngtr", + "gl", + "diamondsuit", + "GT", + "lesssim", + "dsol", + "upharpoonleft", + "SquareIntersection", + "lsime", + "nLt", + "NotLess", + "gnap", + "scap", + "mapstoleft", + "NotLessLess", + "rfloor", + "lfloor", + "nsime", + "bsime", + "NotLessEqual", + "NotLessTilde", + "ncap", + "NotLessGreater", + "precsim", + "looparrowright", + "Pr", + "rcub", + "mapstoup", + "lcub", + "zfr", + "uparrow", + "gne", + "sce", + "Im", + "rcaron", + "lcaron", + "Oopf", + "scaron", + "backsim", + "Tcaron", + "Zcaron", + "ecaron", + "Bernoullis", + "nge", + "tcaron", + "fork", + "Hscr", + "ncaron", + "elsdot", + "tbrk", + "triplus", + "diamond", + "ncup", + "bbrk", + "frown", + "bkarow", + "spades", + "psi", + "Bopf", + "dollar", + "disin", + "spadesuit", + "NotTilde", + "doublebarwedge", + "gap", + "bbrktbrk", + "swarrow", + "bepsi", + "Iscr", + "NotTildeFullEqual", + "eqcolon", + "tint", + "intprod", + "nsupE", + "nwarrow", + "nsubE", + "nges", + "Uparrow", + "ge", + "OpenCurlyDoubleQuote", + "smallsetminus", + "Scaron", + "nvltrie", + "ges", + "blank", + "QUOT", + "block", + "trade", + "jscr", + "wedge", + "Amacr", + "Equal", + "Dcaron", + "DotDot", + "gneq", + "varpropto", + "gneqq", + "Proportional", + "isins", + "eDDot", + "isin", + "TripleDot", + "Fouriertrf", + "Proportion", + "ngeq", + "Lcaron", + "ngeqq", + "lE", + "Ccaron", + "bsemi", + "propto", + "lesdot", + "Conint", + "And", + "searrow", + "orslope", + "harr", + "late", + "CenterDot", + "ofr", + "nearrow", + "qint", + "lates", + "kappav", + "horbar", + "Efr", + "hoarr", + "npre", + "inodot", + "udarr", + "geq", + "nsimeq", + "geqq", + "efDot", + "rpargt", + "Oscr", + "plusdo", + "lagran", + "thicksim", + "precnsim", + "Ncaron", + "napE", + "iiint", + "Bscr", + "mapstodown", + "varrho", + "isinsv", + "nvHarr", + "NotLeftTriangleBar", + "equest", + "NotLeftTriangleEqual", + "NotLeftTriangle", + "Aopf", + "hbar", + "vangrt", + "Hfr", + "range", + "smte", + "lsim", + "npolint", + "dcaron", + "esim", + "Union", + "smtes", + "kopf", + "gopf", + "nsim", + "bsim", + "SmallCircle", + "NotDoubleVerticalBar", + "NotNestedGreaterGreater", + "EqualTilde", + "notindot", + "Rcaron", + "Popf", + "Gopf", + "Ifr", + "wedgeq", + "prod", + "osol", + "DoubleUpArrow", + "Congruent", + "gnsim", + "scsim", + "jfr", + "upsih", + "nLl", + "DoubleUpDownArrow", + "ngsim", + "hearts", + "lesseqgtr", + "nesear", + "Exists", + "smile", + "uwangle", + "heartsuit", + "HorizontalLine", + "GreaterLess", + "rsaquo", + "lsaquo", + "realine", + "Dashv", + "simdot", + "GreaterEqual", + "GreaterTilde", + "GreaterEqualLess", + "GreaterGreater", + "rceil", + "lceil", + "lessgtr", + "oline", + "thksim", + "InvisibleTimes", + "race", + "iquest", + "imagline", + "UpTee", + "midcir", + "ofcir", + "ddarr", + "rangd", + "langd", + "Equilibrium", + "parsim", + "Vdashl", + "Ofr", + "Because", + "rAtail", + "lAtail", + "ominus", + "Ascr", + "Epsilon", + "ShortLeftArrow", + "isinv", + "micro", + "zcaron", + "kscr", + "gscr", + "Bfr", + "gel", + "hercon", + "triminus", + "egrave", + "sdot", + "ugrave", + "Zdot", + "edot", + "NotTildeTilde", + "tdot", + "Pscr", + "Pi", + "Gscr", + "plustwo", + "NotElement", + "PlusMinus", + "hopf", + "gammad", + "mDDot", + "divideontimes", + "doteq", + "varepsilon", + "Precedes", + "Gammad", + "dashv", + "NotCongruent", + "ubreve", + "ogt", + "RoundImplies", + "PrecedesSlantEqual", + "sime", + "Ugrave", + "dbkarow", + "sdote", + "veeeq", + "mapsto", + "times", + "rangle", + "langle", + "leftarrowtail", + "hamilt", + "udhar", + "nisd", + "rfisht", + "lfisht", + "harrcir", + "OpenCurlyQuote", + "ufisht", + "NotHumpDownHump", + "LeftTee", + "rsh", + "lsh", + "gvertneqq", + "timesb", + "scpolint", + "Cdot", + "dwangle", + "Ubreve", + "LeftUpVector", + "LeftUpVectorBar", + "Ecaron", + "homtht", + "igrave", + "npreceq", + "ecolon", + "dd", + "simeq", + "notinE", + "bigoplus", + "Afr", + "leftarrow", + "oint", + "Tab", + "ogon", + "lt", + "nLeftrightarrow", + "rarrb", + "larrb", + "hscr", + "LeftUpDownVector", + "kfr", + "gfr", + "UpArrowBar", + "nsce", + "ltdot", + "gesl", + "xodot", + "star", + "lowbar", + "xharr", + "ecir", + "utdot", + "natur", + "Lsh", + "infin", + "comp", + "sigmav", + "xotime", + "Pfr", + "Gfr", + "bigcap", + "simlE", + "iiiint", + "barwedge", + "Barwed", + "xlarr", + "LessEqualGreater", + "crarr", + "isindot", + "commat", + "middot", + "lesdotor", + "sigmaf", + "rarrbfs", + "larrbfs", + "xrarr", + "bigcup", + "clubs", + "hArr", + "rtrie", + "ltrie", + "imped", + "eogon", + "rx", + "ltrPar", + "Star", + "uogon", + "Tilde", + "half", + "tilde", + "Leftarrow", + "gesles", + "cap", + "strns", + "Lt", + "prnE", + "sqsupe", + "sqsupset", + "tridot", + "order", + "caps", + "cross", + "dfisht", + "xmap", + "sqsup", + "rtri", + "ltri", + "it", + "rmoust", + "lmoust", + "gnE", + "lgE", + "scE", + "utri", + "vellip", + "ETH", + "lmidot", + "Uogon", + "CounterClockwiseContourIntegral", + "ngE", + "nwnear", + "lesg", + "plusb", + "Rsh", + "copysr", + "infintie", + "imath", + "Esim", + "Phi", + "glE", + "vnsup", + "simgE", + "DoubleLongLeftArrow", + "DoubleLongLeftRightArrow", + "nvgt", + "Mellintrf", + "Prime", + "iinfin", + "ReverseElement", + "EmptySmallSquare", + "radic", + "hfr", + "zdot", + "male", + "rarrc", + "prec", + "scnap", + "DifferentialD", + "models", + "ltcir", + "iogon", + "capcap", + "iff", + "ddotseq", + "CirclePlus", + "rthree", + "lthree", + "PrecedesTilde", + "dtdot", + "clubsuit", + "racute", + "lacute", + "trpezium", + "sacute", + "Zacute", + "eacute", + "TildeTilde", + "Uarrocir", + "uacute", + "lowast", + "nacute", + "NotPrecedes", + "Lmidot", + "UpArrow", + "rarrw", + "DownTee", + "FilledSmallSquare", + "capcup", + "GreaterFullEqual", + "nvle", + "trie", + "omicron", + "DoubleRightTee", + "Cconint", + "rsquor", + "lsquor", + "zigrarr", + "copf", + "ContourIntegral", + "hairsp", + "sqsupseteq", + "csub", + "upharpoonright", + "DownBreve", + "ShortDownArrow", + "xopf", + "Sacute", + "vsupnE", + "cir", + "plusacir", + "csup", + "vsubnE", + "Uacute", + "isinE", + "gEl", + "sqcups", + "smid", + "lg", + "DoubleLongRightArrow", + "NotPrecedesSlantEqual", + "eg", + "AMP", + "nmid", + "timesd", + "DownLeftVector", + "zwnj", + "Lacute", + "DownLeftVectorBar", + "ograve", + "Yacute", + "sqcup", + "odot", + "Cacute", + "nu", + "tritime", + "Egrave", + "eplus", + "backcong", + "uplus", + "Edot", + "csupe", + "simg", + "UpperRightArrow", + "csube", + "dtri", + "prnsim", + "boxUr", + "uuarr", + "DownLeftTeeVector", + "gsime", + "bigotimes", + "Dagger", + "Intersection", + "iacute", + "prcue", + "egsdot", + "Implies", + "VDash", + "bump", + "Mu", + "vDash", + "lvnE", + "LeftTeeArrow", + "Nacute", + "UnderBrace", + "Psi", + "rhov", + "lescc", + "sup1", + "sup2", + "sup3", + "bigodot", + "Downarrow", + "xsqcup", + "barvee", + "NegativeMediumSpace", + "bumpe", + "cscr", + "nsc", + "sup", + "cedil", + "boxVr", + "origof", + "zwj", + "Igrave", + "Idot", + "xscr", + "xi", + "nGtv", + "boxHu", + "THORN", + "Racute", + "rarrhk", + "larrhk", + "rtriltri", + "boxV", + "dagger", + "Omicron", + "DoubleVerticalBar", + "nexists", + "Nu", + "nexist", + "gE", + "ap", + "Sup", + "doteqdot", + "eng", + "caron", + "boxHU", + "gesdot", + "ReverseEquilibrium", + "boxUL", + "supmult", + "pitchfork", + "numsp", + "rang", + "lang", + "ocir", + "rationals", + "coprod", + "ltlarr", + "breve", + "nang", + "swarhk", + "raquo", + "laquo", + "supsub", + "Cup", + "ape", + "quest", + "nwarhk", + "supset", + "downarrow", + "duarr", + "apos", + "Ograve", + "shortparallel", + "nsucc", + "LongLeftArrow", + "lesdoto", + "supne", + "nGg", + "raemptyv", + "supsup", + "laemptyv", + "topfork", + "Eogon", + "risingdotseq", + "bumpeq", + "lstrok", + "Tstrok", + "gsim", + "bemptyv", + "zacute", + "gsiml", + "tstrok", + "roang", + "boxVL", + "loang", + "nleqslant", + "sbquo", + "searhk", + "lnapprox", + "Supset", + "boxHd", + "varkappa", + "circeq", + "yopf", + "UnionPlus", + "Lang", + "nearhk", + "shcy", + "cfr", + "Kappa", + "ljcy", + "MediumSpace", + "supseteq", + "supseteqq", + "reg", + "amacr", + "leg", + "weierp", + "TScy", + "supsetneq", + "njcy", + "xfr", + "mu", + "nvinfin", + "boxUR", + "xoplus", + "leftleftarrows", + "sum", + "beth", + "complement", + "num", + "amp", + "boxUl", + "NotGreater", + "boxplus", + "jmath", + "sfrown", + "Dstrok", + "and", + "NotGreaterGreater", + "NotGreaterSlantEqual", + "NotGreaterLess", + "quot", + "NotGreaterFullEqual", + "hyphen", + "planck", + "TildeEqual", + "tosa", + "Lstrok", + "shy", + "xnis", + "Iogon", + "DZcy", + "ohbar", + "cirscir", + "sext", + "para", + "ast", + "questeq", + "Sum", + "DScy", + "ENG", + "ZHcy", + "longleftarrow", + "dash", + "DownTeeArrow", + "supsetneqq", + "profalar", + "oacute", + "boxVR", + "Eacute", + "supplus", + "hookleftarrow", + "CloseCurlyQuote", + "trisb", + "dotsquare", + "rtimes", + "ltimes", + "toea", + "Agrave", + "Assign", + "Rang", + "iocy", + "NotPrecedesEqual", + "aopf", + "chi", + "quaternions", + "boxVl", + "NotGreaterEqual", + "xhArr", + "orderof", + "rsquo", + "lsquo", + "yscr", + "gdot", + "NotSquareSubsetEqual", + "KHcy", + "bsolb", + "NotSquareSubset", + "SHcy", + "YIcy", + "cwint", + "Theta", + "theta", + "xlArr", + "NotSquareSupersetEqual", + "demptyv", + "triangle", + "Gdot", + "NotSquareSuperset", + "Abreve", + "dstrok", + "pertenk", + "rbrack", + "lbrack", + "odsold", + "omid", + "xrArr", + "triangleleft", + "NotGreaterTilde", + "colone", + "Longleftarrow", + "iota", + "colon", + "Zeta", + "gbreve", + "CHcy", + "YUcy", + "REG", + "szlig", + "dzcy", + "beta", + "euro", + "LeftArrow", + "CapitalDifferentialD", + "ring", + "Laplacetrf", + "djcy", + "oplus", + "integers", + "Gbreve", + "ubrcy", + "euml", + "deg", + "uuml", + "Iacute", + "succeq", + "KJcy", + "CupCap", + "tscy", + "cent", + "DJcy", + "TildeFullEqual", + "triangleq", + "duhar", + "LeftDoubleBracket", + "LJcy", + "iecy", + "trianglelefteq", + "nequiv", + "nshortparallel", + "ndash", + "bowtie", + "fjlig", + "Ubrcy", + "vartheta", + "Uuml", + "vartriangleright", + "vartriangleleft", + "ascr", + "succcurlyeq", + "cwconint", + "sc", + "fllig", + "circledast", + "Vdash", + "nVdash", + "suplarr", + "robrk", + "lobrk", + "vdash", + "Yuml", + "gt", + "ccaps", + "Succeeds", + "Oacute", + "TRADE", + "NJcy", + "gtdot", + "yfr", + "compfn", + "Gt", + "scnE", + "ijlig", + "circledS", + "yen", + "thetasym", + "iuml", + "SucceedsSlantEqual", + "boxH", + "mumap", + "rightrightarrows", + "coloneq", + "Sc", + "glj", + "iexcl", + "ccups", + "xcap", + "zhcy", + "boxHD", + "leqslant", + "UpperLeftArrow", + "dblac", + "puncsp", + "ccaron", + "rbbrk", + "lbbrk", + "Aogon", + "LeftTriangleBar", + "gesdotol", + "LeftTriangleEqual", + "LeftTriangle", + "conint", + "drbkarow", + "rtrif", + "ltrif", + "ReverseUpEquilibrium", + "LeftCeiling", + "utrif", + "xcup", + "fallingdotseq", + "rcedil", + "lcedil", + "scedil", + "Tcedil", + "starf", + "boxminus", + "tcedil", + "ZeroWidthSpace", + "ncedil", + "phiv", + "ic", + "capdot", + "dscy", + "check", + "ovbar", + "ntriangleleft", + "RightTee", + "nvge", + "leftrightsquigarrow", + "lozenge", + "RightTriangleBar", + "RightTeeVector", + "RightTriangleEqual", + "RightTriangle", + "Kcedil", + "Scedil", + "cirfnint", + "empty", + "afr", + "DiacriticalTilde", + "LeftDownVector", + "LeftDownVectorBar", + "lEg", + "ApplyFunction", + "bumpE", + "Lcedil", + "caret", + "Barv", + "Ccedil", + "circledR", + "LeftDownTeeVector", + "tshcy", + "DotEqual", + "centerdot", + "ntrianglelefteq", + "minus", + "gimel", + "Aacute", + "gtcir", + "gtrarr", + "bull", + "DownArrow", + "rdquor", + "ldquor", + "intlarhk", + "utilde", + "gacute", + "ntilde", + "af", + "Hstrok", + "exponentiale", + "minusb", + "RightUpTeeVector", + "UpTeeArrow", + "zeta", + "DiacriticalDot", + "DiacriticalDoubleAcute", + "nleftarrow", + "hkswarow", + "iiota", + "apacir", + "Ncedil", + "capand", + "mdash", + "filig", + "scnsim", + "realpart", + "leftthreetimes", + "asymp", + "hellip", + "dtrif", + "NotExists", + "sccue", + "YAcy", + "Utilde", + "NotEqual", + "ThinSpace", + "apE", + "bullet", + "CloseCurlyDoubleQuote", + "Delta", + "gg", + "otimes", + "wreath", + "Rcedil", + "eth", + "supnE", + "awint", + "Breve", + "Gg", + "HumpEqual", + "Lleftarrow", + "boxdr", + "succneqq", + "uring", + "LessSlantEqual", + "nvdash", + "Hacek", + "itilde", + "Iota", + "IOcy", + "boxDr", + "SucceedsTilde", + "LeftFloor", + "Vvdash", + "triangledown", + "LongLeftRightArrow", + "RightFloor", + "DownRightTeeVector", + "quatint", + "Ntilde", + "Bumpeq", + "gvnE", + "boxhu", + "gtlPar", + "nprec", + "ouml", + "gescc", + "Euml", + "Uring", + "UnderBracket", + "nLtv", + "LeftArrowBar", + "ncongdot", + "asympeq", + "minusdu", + "delta", + "harrw", + "andslope", + "cdot", + "Cayleys", + "boxhU", + "succsim", + "cirE", + "sdotb", + "odash", + "cirmid", + "suphsub", + "supdsub", + "supdot", + "awconint", + "TSHcy", + "grave", + "lsimg", + "UpArrowDownArrow", + "LeftVector", + "DoubleRightArrow", + "NegativeThinSpace", + "lhblk", + "cire", + "nVDash", + "uhblk", + "imagpart", + "RightUpDownVector", + "boxdL", + "gla", + "Iuml", + "oelig", + "NotLessSlantEqual", + "boxDL", + "gamma", + "Otimes", + "longleftrightarrow", + "Gamma", + "bigwedge", + "boxhd", + "supE", + "LeftUpTeeVector", + "gesdoto", + "kappa", + "ngeqslant", + "gtrless", + "fflig", + "bigsqcup", + "kgreen", + "supe", + "boxtimes", + "gnapprox", + "downdownarrows", + "biguplus", + "khcy", + "ddagger", + "Ouml", + "Beta", + "minusd", + "succnsim", + "ctdot", + "kjcy", + "gjcy", + "ncong", + "xvee", + "bcong", + "sqsube", + "boxdR", + "Longleftrightarrow", + "sqsub", + "DownLeftRightVector", + "sqsubset", + "NotVerticalBar", + "NotEqualTilde", + "boxdl", + "boxDR", + "andand", + "RightVector", + "IJlig", + "NotTildeEqual", + "angzarr", + "angrt", + "acd", + "andd", + "nrarrc", + "VeryThinSpace", + "Superset", + "boxDl", + "vnsub", + "ccupssm", + "varnothing", + "rcy", + "lcy", + "scy", + "Tcy", + "Zcy", + "ecy", + "rdsh", + "ldsh", + "ucy", + "boxVH", + "tcy", + "ncy", + "bcy", + "ntgl", + "Jcy", + "congdot", + "angst", + "RightDownTeeVector", + "OverParenthesis", + "ltquest", + "pcy", + "otilde", + "rdquo", + "ldquo", + "Vcy", + "capbrcup", + "bdquo", + "DownArrowBar", + "vcy", + "angrtvb", + "Kcy", + "Mcy", + "Scy", + "NewLine", + "fcy", + "Ucy", + "boxVh", + "Dcy", + "hstrok", + "Lcy", + "Ycy", + "supsim", + "NonBreakingSpace", + "OverBar", + "sqsubseteq", + "GJcy", + "OverBrace", + "eqcirc", + "OverBracket", + "Auml", + "acute", + "icy", + "Itilde", + "HilbertSpace", + "omega", + "cacute", + "scirc", + "ecirc", + "ucirc", + "GreaterSlantEqual", + "Jcirc", + "nvDash", + "Wcirc", + "Ncy", + "RightTeeArrow", + "LessFullEqual", + "ltcc", + "aleph", + "dcy", + "Scirc", + "lessapprox", + "IEcy", + "LowerRightArrow", + "Ucirc", + "agrave", + "MinusPlus", + "bigvee", + "Rcy", + "suphsol", + "EmptyVerySmallSquare", + "boxhD", + "precapprox", + "angrtvbd", + "Ycirc", + "sub", + "Otilde", + "Ccirc", + "Fcy", + "complexes", + "subrarr", + "InvisibleComma", + "boxur", + "abreve", + "ntlg", + "icirc", + "xdtri", + "circ", + "gtrdot", + "geqslant", + "ntriangleright", + "cuepr", + "Sub", + "mcy", + "timesbar", + "hksearow", + "sigma", + "cupor", + "oslash", + "dzigrarr", + "leftrightharpoons", + "rightleftharpoons", + "kcedil", + "submult", + "curren", + "LeftTeeVector", + "bigstar", + "cup", + "LongRightArrow", + "Gcedil", + "PrecedesEqual", + "zcy", + "planckh", + "Omega", + "subsub", + "rdca", + "cups", + "ldca", + "subset", + "NotSucceeds", + "LeftArrowRightArrow", + "wcirc", + "RightAngleBracket", + "ntrianglerighteq", + "Sigma", + "NotSucceedsTilde", + "DiacriticalAcute", + "subne", + "Product", + "circleddash", + "subsup", + "copy", + "eta", + "angmsd", + "natural", + "supedot", + "naturals", + "triangleright", + "DiacriticalGrave", + "boxuL", + "cong", + "telrec", + "comma", + "Subset", + "NotSucceedsSlantEqual", + "gtreqless", + "Atilde", + "curarr", + "cudarrr", + "cudarrl", + "subseteq", + "subseteqq", + "rightsquigarrow", + "cupcap", + "subsetneq", + "aogon", + "notinvc", + "rightthreetimes", + "yacute", + "nLeftarrow", + "ocy", + "cemptyv", + "Ecy", + "cupcup", + "trianglerighteq", + "LeftRightArrow", + "succ", + "DownArrowUpArrow", + "OElig", + "chcy", + "gtreqqless", + "angle", + "acE", + "rmoustache", + "lmoustache", + "NegativeVeryThinSpace", + "napprox", + "Oslash", + "subsetneqq", + "Aring", + "boxuR", + "subplus", + "xwedge", + "boxul", + "boxvr", + "HumpDownHump", + "Icy", + "approxeq", + "aacute", + "apid", + "UpDownArrow", + "NestedGreaterGreater", + "jcy", + "gtrsim", + "boxv", + "ocirc", + "Ecirc", + "notnivc", + "bigtriangleup", + "daleth", + "Ocy", + "Hcirc", + "RightVectorBar", + "AElig", + "FilledVerySmallSquare", + "ggg", + "Bcy", + "Poincareplane", + "boxvL", + "PartialD", + "Icirc", + "cularr", + "boxh", + "andv", + "sung", + "RightDoubleBracket", + "jcirc", + "UnderBar", + "RightArrow", + "circledcirc", + "Alpha", + "leftharpoonup", + "cularrp", + "RightArrowLeftArrow", + "varsigma", + "numero", + "ffllig", + "LowerLeftArrow", + "expectation", + "Ocirc", + "yacy", + "lambda", + "NotSucceedsEqual", + "boxvR", + "bigtriangledown", + "ang", + "xuplus", + "nabla", + "boxvl", + "Eta", + "Acy", + "kcy", + "gcy", + "LeftRightVector", + "ccedil", + "Backslash", + "hslash", + "Pcy", + "Gcy", + "gtquest", + "Lambda", + "odiv", + "leftharpoondown", + "longmapsto", + "Jukcy", + "ldrdhar", + "xutri", + "nRightarrow", + "ExponentialE", + "nrightarrow", + "Acirc", + "NoBreak", + "gcirc", + "ange", + "curarrm", + "SHCHcy", + "yuml", + "subnE", + "DDotrahd", + "RuleDelayed", + "Gcirc", + "Jsercy", + "gtcc", + "iukcy", + "updownarrow", + "curlyvee", + "ffilig", + "yicy", + "divonx", + "gtrapprox", + "subdot", + "leftrightarrows", + "auml", + "Updownarrow", + "rightleftarrows", + "DownRightVector", + "DownRightVectorBar", + "hcirc", + "Rrightarrow", + "longrightarrow", + "cupdot", + "ac", + "hookrightarrow", + "NegativeThickSpace", + "subE", + "twoheadrightarrow", + "downharpoonright", + "downharpoonleft", + "aelig", + "rdldhar", + "curlywedge", + "hybull", + "sube", + "Longrightarrow", + "Cedilla", + "notinva", + "SucceedsEqual", + "leftrightarrow", + "straightepsilon", + "amalg", + "atilde", + "RightCeiling", + "Leftrightarrow", + "subsim", + "VerticalLine", + "RightUpVector", + "RightUpVectorBar", + "RightDownVector", + "RightDownVectorBar", + "alefsym", + "circlearrowright", + "circlearrowleft", + "Iukcy", + "otimesas", + "intercal", + "thickapprox", + "jukcy", + "notniva", + "precnapprox", + "cuvee", + "aring", + "ccirc", + "rightarrow", + "Integral", + "xcirc", + "jsercy", + "checkmark", + "VerticalTilde", + "boxvH", + "NotRightTriangleBar", + "NotRightTriangleEqual", + "NotRightTriangle", + "LeftVectorBar", + "boxvh", + "boxbox", + "ycy", + "subedot", + "SOFTcy", + "Rightarrow", + "alpha", + "shchcy", + "softcy", + "acy", + "ycirc", + "bigcirc", + "ImaginaryI", + "approx", + "SupersetEqual", + "vzigzag", + "cuesc", + "UnderParenthesis", + "acirc", + "succapprox", + "mcomma", + "angmsdae", + "angmsdab", + "angmsdaf", + "angsph", + "luruhar", + "angmsdad", + "twoheadleftarrow", + "cylcty", + "straightphi", + "multimap", + "RightArrowBar", + "ldrushar", + "LeftAngleBracket", + "ruluhar", + "curlyeqprec", + "yucy", + "lurdshar", + "hardcy", + "rightharpoondown", + "rightharpoonup", + "HARDcy", + "SubsetEqual", + "digamma", + "udblac", + "SuchThat", + "cuwed", + "Udblac", + "angmsdag", + "angmsdah", + "VerticalBar", + "VerticalSeparator", + "rightarrowtail", + "odblac", + "succnapprox", + "angmsdac", + "Odblac", + "cupbrcap", + "angmsdaa", + "curlyeqsucc", + "curvearrowleft", + "curvearrowright" + }; +#define entity_pool ((const char *) &entity_pool_contents) +const struct html_ent * +find_entity (register const char *str, register unsigned int len) +{ + static const unsigned char lengthtable[] = + { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 6, 0, 6, 5, 0, 5, 3, 4, + 3, 4, 0, 4, 0, 2, 5, 4, 0, 0, 0, 2, 0, 7, + 0, 7, 3, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 6, + 0, 0, 0, 3, 6, 0, 4, 0, 0, 0, 0, 6, 4, 5, + 0, 0, 0, 5, 0, 5, 0, 6, 0, 0, 0, 4, 5, 5, + 5, 3, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, + 0, 0, 0, 3, 4, 0, 3, 0, 0, 5, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 0, + 5, 0, 5, 6, 0, 6, 5, 0, 2, 5, 0, 5, 0, 0, + 0, 0, 4, 0, 0, 0, 3, 0, 3, 5, 0, 0, 5, 0, + 0, 0, 6, 0, 10, 0, 4, 0, 0, 5, 3, 5, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 6, 6, + 0, 6, 0, 0, 0, 0, 6, 0, 6, 0, 2, 0, 0, 0, + 4, 7, 0, 7, 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 4, 0, 4, 6, 0, 3, 0, 0, 0, 0, 0, 0, 4, + 4, 3, 0, 4, 0, 0, 2, 0, 0, 0, 4, 0, 4, 0, + 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 2, 0, 0, 0, 5, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 3, 2, 4, 0, 6, 0, 0, 3, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 6, 0, 3, 4, 0, 0, 0, + 0, 4, 6, 0, 0, 0, 5, 5, 5, 0, 13, 0, 0, 4, + 0, 0, 5, 0, 4, 4, 5, 17, 18, 0, 0, 0, 0, 0, + 5, 0, 0, 17, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, + 5, 5, 0, 0, 0, 8, 0, 0, 0, 3, 0, 0, 6, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 6, 0, 0, + 0, 4, 0, 0, 5, 0, 6, 6, 6, 6, 6, 6, 6, 0, + 0, 6, 0, 6, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, + 6, 0, 6, 3, 4, 0, 0, 4, 3, 5, 0, 0, 3, 0, + 0, 0, 11, 5, 0, 0, 0, 4, 0, 0, 6, 0, 0, 0, + 5, 0, 0, 0, 5, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 5, 3, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 4, 0, 4, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 5, 0, 0, 0, 0, + 3, 6, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 4, 6, + 0, 0, 8, 0, 8, 0, 2, 0, 0, 0, 0, 4, 0, 0, + 0, 4, 0, 6, 0, 0, 0, 0, 6, 0, 4, 0, 0, 0, + 0, 6, 0, 5, 6, 2, 5, 8, 5, 0, 0, 4, 0, 4, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 9, 0, 4, 4, + 4, 0, 4, 6, 4, 4, 4, 0, 0, 0, 5, 4, 5, 4, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 4, 5, 4, + 5, 0, 0, 4, 0, 5, 0, 0, 0, 4, 0, 0, 0, 0, + 4, 4, 0, 5, 0, 0, 11, 0, 0, 6, 0, 0, 3, 0, + 0, 0, 0, 6, 0, 4, 0, 0, 4, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 7, 4, 4, 0, 7, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 3, 8, 4, 0, 0, 0, 5, 0, 6, 0, + 0, 0, 0, 6, 0, 4, 0, 0, 0, 5, 0, 6, 0, 0, + 0, 5, 5, 0, 0, 3, 6, 2, 0, 0, 4, 0, 0, 7, + 0, 4, 0, 4, 4, 4, 3, 5, 0, 0, 0, 0, 0, 0, + 6, 0, 4, 4, 0, 0, 0, 12, 13, 0, 0, 6, 8, 0, + 2, 0, 0, 17, 0, 0, 0, 4, 0, 5, 0, 7, 0, 5, + 0, 0, 0, 5, 4, 5, 0, 0, 3, 0, 0, 0, 5, 0, + 5, 12, 13, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 7, 0, 0, 6, 6, 6, 0, 4, 0, + 0, 0, 0, 17, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 3, 6, 9, 0, 0, + 0, 9, 0, 0, 0, 0, 0, 6, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 19, 0, 5, 0, 0, 17, 0, 0, + 14, 0, 0, 0, 0, 12, 4, 0, 0, 0, 4, 0, 2, 0, + 4, 0, 6, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 0, + 4, 0, 4, 4, 4, 0, 0, 0, 0, 4, 0, 4, 0, 4, + 9, 0, 0, 4, 2, 0, 0, 4, 2, 4, 4, 0, 0, 0, + 0, 4, 6, 0, 0, 6, 9, 4, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 4, 2, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 6, 0, 0, + 0, 0, 6, 4, 6, 4, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 9, 0, 0, 4, 0, 0, 0, 0, 0, + 7, 4, 4, 7, 0, 7, 5, 0, 0, 6, 4, 4, 4, 0, + 4, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 4, 0, + 0, 0, 4, 0, 0, 4, 4, 6, 0, 0, 0, 3, 5, 3, + 5, 11, 4, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 5, 0, 5, 0, 0, 0, 3, 5, 4, + 0, 0, 0, 5, 0, 6, 9, 7, 2, 0, 4, 0, 0, 4, + 0, 0, 0, 0, 4, 5, 6, 0, 0, 0, 0, 9, 10, 0, + 0, 0, 5, 0, 0, 0, 0, 11, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 4, 8, 6, 0, 0, 0, 0, 0, 8, 0, 0, + 0, 0, 0, 0, 0, 5, 6, 0, 0, 0, 13, 5, 5, 6, + 0, 0, 0, 0, 2, 0, 0, 0, 4, 2, 4, 0, 0, 6, + 4, 0, 4, 0, 0, 0, 4, 0, 21, 0, 0, 0, 6, 0, + 3, 0, 0, 0, 6, 6, 0, 3, 13, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 4, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 7, 3, 0, 0, + 0, 0, 0, 0, 0, 7, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, + 3, 15, 3, 3, 3, 0, 0, 0, 3, 3, 6, 3, 6, 0, + 0, 0, 0, 3, 0, 0, 4, 3, 0, 3, 0, 12, 0, 0, + 0, 3, 0, 4, 0, 0, 0, 3, 0, 12, 0, 4, 5, 0, + 9, 0, 0, 7, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, + 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, + 0, 3, 3, 0, 0, 6, 0, 0, 0, 0, 0, 4, 0, 0, + 3, 3, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 3, 7, 0, 0, 8, 0, 0, 0, 0, + 0, 0, 3, 4, 0, 6, 0, 0, 0, 15, 0, 0, 0, 0, + 0, 0, 0, 9, 0, 0, 0, 2, 0, 0, 0, 0, 9, 3, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 7, 3, 24, 0, 0, + 0, 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 7, 4, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 3, 3, + 0, 4, 0, 7, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 5, 2, 0, 0, 0, 6, 0, 3, 8, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 9, 5, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 7, 15, 7, 8, 4, 0, 5, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 4, 4, 5, 0, 0, 0, 0, 6, 14, 3, + 15, 0, 6, 0, 0, 0, 3, 0, 3, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 5, 16, 0, 5, 10, 0, 0, 0, + 5, 7, 0, 5, 0, 0, 6, 0, 3, 0, 0, 11, 5, 0, + 0, 4, 5, 0, 0, 5, 0, 0, 3, 0, 0, 0, 0, 8, + 0, 0, 0, 5, 0, 0, 0, 6, 3, 0, 0, 0, 0, 0, + 5, 0, 0, 3, 3, 3, 0, 0, 0, 6, 0, 0, 5, 6, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 11, 0, 6, 0, 6, 0, 0, 13, 0, 0, 7, + 0, 0, 0, 0, 7, 0, 6, 4, 5, 0, 3, 0, 0, 5, + 3, 0, 0, 0, 0, 0, 6, 0, 0, 4, 0, 0, 0, 0, + 3, 6, 5, 0, 0, 0, 0, 11, 0, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 0, 11, 0, 5, 5, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 8, 0, 7, 4, 0, 0, 0, 0, 5, 4, 9, + 0, 0, 5, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, + 0, 6, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 4, 0, 0, 14, 5, 0, 0, 8, + 0, 0, 0, 20, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 3, 0, 0, 4, 6, 0, 0, 0, 0, 6, 0, 0, 0, 7, + 0, 3, 6, 4, 6, 0, 0, 0, 0, 0, 0, 6, 3, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, + 0, 11, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 4, + 0, 0, 0, 0, 0, 0, 0, 13, 18, 5, 0, 3, 0, 7, + 0, 4, 0, 0, 0, 4, 0, 0, 10, 11, 0, 0, 0, 6, + 0, 6, 0, 0, 5, 0, 5, 12, 12, 0, 0, 0, 4, 0, + 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 14, 0, 0, 0, 2, 4, 8, 4, 0, 3, 0, 0, 7, 0, + 3, 0, 0, 0, 3, 2, 0, 0, 0, 0, 6, 0, 6, 4, + 6, 7, 6, 6, 6, 0, 10, 0, 0, 0, 3, 6, 0, 4, + 0, 0, 0, 0, 0, 4, 0, 6, 6, 0, 4, 0, 0, 0, + 7, 0, 0, 7, 0, 0, 4, 0, 4, 0, 5, 6, 0, 6, + 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 8, 14, 0, 3, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 7, 5, 0, 0, 0, 4, 0, 0, 0, + 17, 7, 0, 0, 4, 0, 0, 7, 0, 5, 0, 0, 7, 5, + 0, 0, 4, 0, 7, 2, 20, 0, 0, 0, 0, 13, 0, 0, + 0, 0, 6, 0, 7, 3, 5, 4, 0, 0, 0, 0, 5, 5, + 0, 0, 0, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 5, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 4, 9, 0, 5, 12, 0, 0, 0, 0, 5, 0, 5, + 4, 0, 0, 0, 9, 0, 0, 0, 10, 10, 0, 0, 4, 6, + 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 6, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 6, 6, 0, 3, 0, 0, 0, + 7, 0, 0, 0, 0, 7, 4, 0, 0, 0, 0, 0, 4, 0, + 9, 0, 0, 3, 0, 0, 0, 7, 0, 4, 0, 0, 5, 6, + 0, 0, 6, 3, 5, 4, 0, 0, 0, 0, 0, 6, 0, 5, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 6, 0, 0, 6, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 10, 0, 0, 6, 0, 6, 0, 0, 6, + 0, 0, 18, 0, 6, 0, 20, 15, 0, 0, 4, 4, 0, 0, + 0, 6, 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 4, 4, + 0, 7, 0, 6, 0, 4, 0, 5, 0, 0, 0, 0, 5, 0, + 0, 0, 4, 4, 0, 0, 0, 0, 4, 0, 4, 0, 11, 0, + 20, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 10, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 4, 0, 0, 3, 0, 0, 6, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 0, 0, 0, 0, 0, 13, 0, 0, 9, 0, 0, 0, 5, + 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 3, 0, 0, 17, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 9, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 7, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 14, 0, + 0, 11, 0, 6, 0, 6, 0, 7, 5, 0, 0, 0, 6, 12, + 12, 0, 0, 0, 0, 16, 0, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, 0, 0, 7, + 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 14, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 5, 0, 5, 0, 0, 0, 0, 0, 11, 6, 6, 3, 0, 0, + 0, 0, 7, 0, 6, 0, 6, 6, 4, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, + 4, 4, 0, 0, 0, 0, 3, 3, 6, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 6, 0, + 4, 4, 0, 0, 0, 0, 13, 0, 4, 0, 0, 0, 0, 4, + 2, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 10, 0, 9, 0, 0, 4, 6, 0, 5, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 8, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 12, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 12, 0, + 0, 0, 0, 0, 0, 0, 18, 0, 0, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 7, 0, 0, 0, 0, 5, 0, 5, + 0, 0, 0, 6, 0, 0, 5, 0, 0, 6, 0, 6, 0, 0, + 13, 6, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 6, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 6, 15, 0, 0, 7, 0, 3, 0, 3, 0, 0, 0, + 9, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 15, + 0, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 7, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 9, 4, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 2, 15, 0, 0, + 0, 5, 0, 5, 0, 4, 0, 0, 0, 0, 0, 0, 16, 0, + 3, 3, 10, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 4, + 5, 4, 0, 0, 6, 0, 5, 4, 0, 5, 5, 3, 5, 0, + 4, 0, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 8, 6, 0, 0, 0, 0, 0, 0, 0, 5, 16, 0, + 5, 7, 0, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 5, 0, 0, + 0, 0, 6, 0, 5, 4, 5, 0, 5, 5, 0, 0, 0, 0, + 5, 2, 6, 4, 0, 5, 0, 0, 5, 0, 4, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 3, 5, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 6, 5, 0, 0, 4, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 4, 2, 6, 0, 6, 3, 3, 0, 0, + 3, 0, 4, 0, 6, 0, 3, 0, 0, 6, 0, 5, 31, 0, + 0, 0, 0, 0, 0, 0, 3, 6, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, 6, + 0, 8, 0, 5, 4, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0, + 0, 0, 19, 0, 0, 0, 0, 24, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 5, + 0, 0, 0, 6, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, + 0, 16, 5, 0, 0, 3, 4, 4, 0, 5, 4, 5, 0, 0, + 0, 13, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 6, 0, 3, + 0, 7, 0, 10, 0, 0, 0, 0, 6, 0, 6, 0, 0, 13, + 0, 0, 0, 5, 0, 8, 0, 6, 0, 6, 8, 6, 0, 0, + 6, 6, 0, 10, 0, 8, 6, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 11, 0, 0, 0, 6, 0, 0, 0, + 0, 7, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 17, 6, 0, 0, 0, 0, 0, 16, 0, 0, + 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 7, 0, + 14, 7, 6, 0, 6, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 10, 4, 14, 0, 0, 0, 9, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 4, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 6, 3, 8, 4, 6, 6, 0, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 6, 0, 4, 0, 2, 0, 20, 21, 0, 0, 2, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 0, 14, 4, 6, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 5, 0, 0, + 4, 6, 0, 2, 7, 0, 6, 5, 0, 8, 0, 0, 5, 0, + 4, 0, 0, 0, 5, 0, 4, 15, 5, 0, 4, 6, 0, 0, + 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 17, 5, 0, + 0, 0, 9, 6, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 7, 5, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 12, 0, 0, 0, 6, 0, 0, 0, 0, 10, 3, 0, 0, + 0, 4, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 7, 0, 0, + 0, 0, 0, 0, 9, 0, 6, 0, 6, 0, 0, 0, 0, 19, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 5, 0, 6, 3, 6, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 2, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 6, 0, 6, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 17, 0, + 0, 7, 0, 0, 2, 6, 2, 0, 0, 0, 2, 0, 0, 0, + 0, 3, 8, 0, 0, 3, 0, 5, 0, 5, 6, 0, 0, 0, + 0, 18, 0, 0, 0, 0, 5, 0, 7, 0, 0, 9, 0, 0, + 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 4, 0, 4, 0, 0, 4, 0, 9, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 5, 0, 4, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 5, 0, 5, 6, + 0, 0, 0, 3, 3, 5, 0, 0, 0, 0, 6, 0, 0, 0, + 6, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 4, + 6, 13, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 8, 6, 8, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 12, 0, 6, 0, 0, 0, 6, 0, 0, + 0, 6, 4, 0, 0, 7, 6, 5, 0, 0, 6, 0, 5, 5, + 5, 0, 0, 0, 9, 0, 0, 0, 0, 0, 5, 0, 6, 8, + 0, 0, 6, 0, 5, 8, 0, 0, 0, 6, 0, 4, 0, 9, + 0, 0, 0, 0, 4, 6, 4, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, + 11, 0, 0, 8, 9, 0, 0, 0, 0, 3, 5, 3, 0, 0, + 0, 0, 6, 4, 0, 0, 0, 9, 4, 3, 0, 2, 0, 0, + 0, 0, 0, 7, 5, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 14, 3, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 10, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 10, 7, + 5, 0, 6, 0, 6, 0, 3, 17, 0, 0, 0, 0, 0, 0, + 20, 0, 14, 4, 0, 0, 0, 0, 0, 0, 19, 6, 6, 0, + 10, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 6, 0, + 0, 3, 0, 0, 0, 4, 5, 0, 0, 4, 0, 5, 0, 0, + 0, 0, 0, 0, 7, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 7, 0, 3, 0, 4, 0, 3, 0, 4, 0, 0, 13, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 6, 0, 0, 0, 0, 0, 7, 0, 13, 0, 0, 15, 0, 0, + 5, 9, 0, 0, 0, 6, 0, 6, 0, 0, 4, 6, 0, 0, + 6, 4, 4, 0, 16, 0, 4, 0, 3, 0, 0, 11, 5, 15, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 7, 0, 0, 5, 0, 5, 4, 0, 0, 4, 0, + 20, 4, 0, 0, 0, 0, 0, 5, 15, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 22, 0, 0, 7, + 8, 0, 4, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 6, 7, 0, 0, 0, 0, 6, 0, 6, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 4, 0, 5, 0, 12, 15, 6, 0, + 13, 0, 4, 0, 5, 4, 6, 0, 0, 0, 0, 4, 0, 0, + 4, 3, 5, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 9, 0, 0, 20, 0, 4, 10, + 0, 0, 0, 0, 4, 0, 5, 0, 0, 8, 6, 0, 5, 4, + 0, 0, 3, 0, 4, 0, 0, 6, 6, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 9, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 17, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 14, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 14, 0, 0, 0, 0, 0, 0, 5, 6, 0, 5, 0, 0, + 0, 0, 0, 0, 5, 0, 8, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 16, 15, 4, 0, 0, 11, 0, 0, 0, 8, 0, 0, + 0, 0, 0, 0, 0, 2, 0, 5, 0, 10, 0, 0, 5, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, + 5, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 4, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 6, 5, 4, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, + 0, 0, 0, 2, 4, 5, 0, 0, 0, 8, 0, 0, 3, 0, + 8, 0, 0, 4, 18, 0, 0, 0, 0, 4, 5, 0, 0, 0, + 16, 0, 0, 0, 0, 7, 0, 2, 3, 5, 0, 0, 5, 0, + 4, 4, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 14, 0, 0, 0, 0, 5, 0, 0, 6, 0, 6, 0, + 5, 0, 5, 0, 5, 15, 0, 0, 8, 17, 12, 0, 0, 0, + 0, 0, 6, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 5, 0, 0, 20, 0, 0, 0, 0, 0, + 11, 0, 5, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 13, + 0, 0, 0, 0, 0, 6, 0, 6, 0, 6, 0, 6, 0, 5, + 8, 0, 0, 0, 0, 0, 6, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, + 0, 13, 0, 0, 0, 0, 0, 8, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 16, 0, 14, 0, 18, 13, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 16, 0, 0, 0, 0, 0, + 0, 14, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 8, 17, 0, 0, 0, 5, 0, 0, 0, 8, 0, + 0, 0, 0, 0, 0, 0, 9, 0, 15, 0, 5, 0, 5, 0, + 0, 0, 0, 0, 0, 6, 5, 0, 0, 0, 0, 6, 4, 0, + 0, 9, 0, 0, 0, 0, 0, 6, 0, 6, 0, 0, 8, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 6, 2, 0, 0, 6, 0, 12, 6, 0, 0, 0, 16, 0, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 0, 14, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 10, 8, 0, 5, 0, 0, 6, + 0, 0, 0, 6, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 14, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, 9, 0, + 0, 0, 5, 0, 0, 0, 0, 4, 6, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 21, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 6, 0, 0, 0, 0, 0, 3, 5, 0, + 0, 5, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 2, 0, + 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 14, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 5, 6, 0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 13, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 0, 0, 0, 18, 10, 0, 0, 18, 0, 7, 0, 0, + 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 0, 5, 0, 0, 0, 0, 6, 0, 0, 5, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 4, 0, + 0, 0, 5, 0, 12, 4, 12, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 5, 0, 5, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 4, 0, 0, 0, 0, + 7, 5, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 4, + 5, 0, 0, 0, 5, 6, 7, 7, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 8, 0, 0, 0, 0, 5, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 10, 16, 0, 0, 0, 0, 0, 0, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 4, 6, 0, 0, 0, 5, 0, 0, 0, 8, 0, 0, 0, 0, + 0, 17, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 0, 17, 0, 5, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 8, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4, 0, + 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 8, 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 0, 4, 6, 8, 0, 5, 0, + 0, 4, 4, 0, 5, 4, 5, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 5, 0, 0, 18, 0, 5, 0, 0, 0, 19, 0, 0, + 8, 0, 14, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 11, 0, 5, 13, 0, 0, 0, 7, + 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 3, 0, 0, + 4, 0, 6, 13, 0, 8, 0, 5, 0, 0, 0, 5, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, + 3, 0, 3, 0, 3, 0, 3, 3, 3, 4, 0, 4, 0, 3, + 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, + 4, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 5, + 0, 18, 0, 0, 15, 7, 0, 3, 0, 0, 6, 5, 0, 5, + 0, 3, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, + 7, 10, 0, 0, 0, 0, 0, 4, 0, 0, 9, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 11, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 12, 0, 0, 0, 5, 6, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 5, 0, 17, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, 0, 6, 5, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 15, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 6, 0, 9, 6, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 7, 0, 0, 20, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 0, 0, + 0, 3, 0, 0, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 14, 0, 0, 0, 0, 5, 6, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 8, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 6, 8, 0, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 17, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 13, 0, 0, 0, 0, 7, 0, 0, 3, 14, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 7, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 6, 11, 19, 0, + 0, 5, 17, 0, 0, 0, 0, 0, 16, 5, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, + 7, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 7, 8, 0, 0, 0, 0, 0, 13, 0, 16, 5, 4, + 0, 0, 0, 6, 0, 0, 5, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, + 9, 6, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8, + 9, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 5, 7, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 6, 0, 0, 0, + 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, + 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 4, 10, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 10, 0, 10, 0, + 0, 0, 21, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 11, 0, 20, 0, 3, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, + 0, 3, 0, 0, 0, 0, 5, 14, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 5, 0, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 8, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 5, 0, 0, + 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 7, 0, + 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 5, 0, + 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 6, 0, 0, 0, 0, 0, 16, 5, 0, 15, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 0, 0, 6, 0, 0, 0, 9, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 11, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, 4, 7, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 8, 0, 0, + 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 4, + 0, 0, 11, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 18, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 18, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 15, 0, 0, + 0, 0, 5, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 0, 0, 12, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 13, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 18, 0, 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 15, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 11, 0, + 0, 5, 0, 0, 0, 7, 0, 0, 0, 11, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 21, 16, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 10, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, + 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15 + }; + static const struct html_ent wordlist[] = + { + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1501 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str39), {226, 134, 146, 0}}, + {-1,{0}}, +#line 833 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str41), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 844 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str49), {226, 170, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1903 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str52), {226, 134, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1235 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str55), {226, 138, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1510 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str62), {226, 134, 163, 0}}, + {-1,{0}}, +#line 841 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str64), {226, 134, 162, 0}}, +#line 1601 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str65), {226, 135, 190, 0}}, + {-1,{0}}, +#line 963 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str67), {226, 135, 189, 0}}, +#line 1168 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str68), {194, 172, 0}}, +#line 1609 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str69), {41, 0}}, +#line 146 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str70), {226, 138, 165, 0}}, +#line 989 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str71), {40, 0}}, + {-1,{0}}, +#line 1715 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str73), {226, 136, 165, 0}}, + {-1,{0}}, +#line 945 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str75), {226, 137, 170, 0}}, +#line 1926 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str76), {226, 134, 190, 0}}, +#line 505 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str77), {226, 139, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 482 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str81), {226, 170, 153, 0}}, + {-1,{0}}, +#line 1607 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str83), {226, 168, 181, 0}}, + {-1,{0}}, +#line 981 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str85), {226, 168, 180, 0}}, +#line 1388 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str86), {226, 136, 165, 0}}, + {-1,{0}}, +#line 1132 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str88), {226, 134, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1231 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str94), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1872 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str97), {226, 128, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 486 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str101), {226, 170, 149, 0}}, +#line 506 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str102), {226, 167, 163, 0}}, + {-1,{0}}, +#line 500 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str104), {226, 128, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 193 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str109), {226, 128, 181, 0}}, +#line 955 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str110), {226, 170, 137, 0}}, +#line 137 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str111), {226, 150, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 136 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str115), {226, 150, 146, 0}}, + {-1,{0}}, +#line 138 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str117), {226, 150, 147, 0}}, + {-1,{0}}, +#line 1232 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str119), {226, 171, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1143 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str123), {226, 128, 165, 0}}, +#line 1594 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str124), {226, 135, 132, 0}}, +#line 1233 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str125), {226, 136, 130, 0}}, +#line 944 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str126), {226, 135, 135, 0}}, +#line 1158 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str127), {226, 137, 174, 0}}, +#line 1696 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str128), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1230 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str138), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1825 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str143), {206, 164, 0}}, +#line 1991 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str144), {226, 134, 149, 0}}, + {-1,{0}}, +#line 1738 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str146), {226, 150, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1141 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str149), {226, 134, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1826 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str152), {207, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 957 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str165), {226, 170, 135, 0}}, +#line 1612 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str166), {226, 135, 137, 0}}, + {-1,{0}}, +#line 991 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str168), {226, 135, 134, 0}}, + {-1,{0}}, +#line 1740 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str170), {226, 134, 146, 0}}, +#line 1556 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str171), {226, 165, 172, 0}}, + {-1,{0}}, +#line 940 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str173), {226, 165, 170, 0}}, +#line 525 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str174), {226, 165, 177, 0}}, + {-1,{0}}, +#line 1433 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str176), {226, 137, 186, 0}}, +#line 1555 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str177), {226, 135, 128, 0}}, + {-1,{0}}, +#line 939 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str179), {226, 134, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1904 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str184), {226, 134, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1128 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str188), {226, 137, 171, 0}}, + {-1,{0}}, +#line 140 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str190), {61, 0}}, +#line 1241 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str191), {226, 134, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1818 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str194), {226, 134, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1497 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str198), {226, 165, 181, 0}}, + {-1,{0}}, +#line 1966 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str200), {226, 135, 136, 0}}, + {-1,{0}}, +#line 344 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str202), {226, 134, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1516 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str205), {226, 164, 141, 0}}, +#line 397 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str206), {194, 168, 0}}, +#line 847 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str207), {226, 164, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1306 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str215), {226, 134, 150, 0}}, + {-1,{0}}, +#line 1703 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str217), {226, 170, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 496 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str222), {226, 128, 133, 0}}, +#line 1507 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str223), {226, 165, 133, 0}}, + {-1,{0}}, +#line 839 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str225), {226, 164, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1405 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str230), {226, 132, 179, 0}}, + {-1,{0}}, +#line 495 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str232), {226, 128, 132, 0}}, + {-1,{0}}, +#line 1013 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str234), {60, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 834 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str238), {226, 134, 158, 0}}, +#line 1524 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str239), {226, 166, 144, 0}}, + {-1,{0}}, +#line 854 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str241), {226, 166, 141, 0}}, + {-1,{0}}, +#line 1081 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str243), {197, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1145 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str251), {226, 137, 176, 0}}, + {-1,{0}}, +#line 1553 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str253), {226, 165, 164, 0}}, + {-1,{0}}, +#line 937 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str255), {226, 165, 162, 0}}, +#line 1476 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str256), {226, 129, 151, 0}}, + {-1,{0}}, +#line 828 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str258), {226, 170, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1086 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str265), {194, 160, 0}}, +#line 1924 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str266), {226, 165, 163, 0}}, +#line 1867 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str267), {226, 138, 164, 0}}, + {-1,{0}}, +#line 2003 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str269), {226, 171, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 946 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str272), {226, 139, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1431 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str276), {226, 170, 183, 0}}, + {-1,{0}}, +#line 497 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str278), {226, 128, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1078 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str281), {226, 137, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 975 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str294), {226, 134, 171, 0}}, + {-1,{0}}, +#line 869 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str296), {226, 137, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1669 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str300), {226, 153, 175, 0}}, + {-1,{0}}, +#line 473 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str302), {226, 133, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 913 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str310), {226, 169, 189, 0}}, +#line 744 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str311), {226, 136, 136, 0}}, +#line 1460 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str312), {226, 136, 157, 0}}, + {-1,{0}}, +#line 1865 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str314), {226, 140, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 749 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str317), {226, 136, 171, 0}}, + {-1,{0}}, +#line 1104 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str319), {226, 137, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1236 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str329), {226, 139, 160, 0}}, + {-1,{0}}, +#line 1446 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str331), {226, 170, 175, 0}}, +#line 508 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str332), {206, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1959 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str337), {207, 133, 0}}, +#line 1838 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str338), {226, 136, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1522 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str342), {226, 166, 140, 0}}, +#line 1657 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str343), {226, 134, 152, 0}}, +#line 852 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str344), {226, 166, 139, 0}}, + {-1,{0}}, +#line 131 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str346), {226, 150, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 959 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str349), {226, 170, 135, 0}}, + {-1,{0}}, {-1,{0}}, +#line 960 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str352), {226, 137, 168, 0}}, + {-1,{0}}, +#line 1417 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str354), {43, 0}}, +#line 1153 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str355), {226, 169, 189, 0}}, +#line 1105 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str356), {226, 137, 144, 0}}, +#line 133 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str357), {226, 151, 130, 0}}, +#line 134 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str358), {226, 150, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1101 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str364), {226, 134, 151, 0}}, + {-1,{0}}, {-1,{0}}, +#line 132 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str367), {226, 150, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1154 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str373), {226, 137, 174, 0}}, +#line 489 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str374), {196, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2033 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str378), {226, 136, 157, 0}}, +#line 1933 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str379), {197, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1700 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str383), {226, 167, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1032 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str387), {226, 164, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1419 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str390), {226, 168, 165, 0}}, +#line 1167 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str391), {226, 171, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2018 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str408), {226, 128, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1398 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str426), {226, 138, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 560 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str430), {226, 150, 177, 0}}, +#line 1422 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str431), {194, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1150 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str435), {226, 137, 176, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1151 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str438), {226, 137, 166, 0}}, + {-1,{0}}, +#line 578 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str440), {194, 190, 0}}, +#line 572 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str441), {194, 188, 0}}, +#line 2017 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str442), {124, 0}}, +#line 570 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str443), {194, 189, 0}}, +#line 579 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str444), {226, 133, 151, 0}}, +#line 573 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str445), {226, 133, 149, 0}}, +#line 581 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str446), {226, 133, 152, 0}}, + {-1,{0}}, {-1,{0}}, +#line 577 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str449), {226, 133, 150, 0}}, + {-1,{0}}, +#line 571 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str451), {226, 133, 147, 0}}, + {-1,{0}}, +#line 574 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str453), {226, 133, 153, 0}}, +#line 1465 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str454), {226, 138, 176, 0}}, +#line 576 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str455), {226, 133, 148, 0}}, +#line 580 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str456), {226, 133, 156, 0}}, +#line 575 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str457), {226, 133, 155, 0}}, +#line 582 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str458), {226, 133, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 583 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str462), {226, 133, 157, 0}}, + {-1,{0}}, +#line 584 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str464), {226, 133, 158, 0}}, +#line 909 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str465), {226, 137, 164, 0}}, +#line 343 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str466), {226, 134, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1960 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str469), {207, 146, 0}}, +#line 398 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str470), {203, 153, 0}}, +#line 1406 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str471), {226, 152, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 218 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str474), {226, 139, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 130 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str478), {226, 150, 170, 0}}, +#line 1599 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str479), {226, 171, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 910 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str483), {226, 137, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 748 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str486), {226, 138, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 371 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str490), {226, 135, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1554 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str494), {226, 135, 129, 0}}, + {-1,{0}}, +#line 938 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str496), {226, 134, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1420 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str505), {226, 169, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1932 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str511), {197, 170, 0}}, +#line 2014 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str512), {226, 139, 129, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1502 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str515), {226, 134, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 303 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str527), {226, 168, 175, 0}}, + {-1,{0}}, +#line 1619 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str529), {93, 0}}, + {-1,{0}}, +#line 1005 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str531), {91, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1509 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str538), {226, 164, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 529 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str541), {226, 137, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2013 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str546), {226, 136, 168, 0}}, +#line 1088 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str547), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 947 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str553), {226, 140, 158, 0}}, +#line 569 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str554), {226, 168, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1739 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str558), {226, 150, 170, 0}}, +#line 1413 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str559), {226, 132, 143, 0}}, + {-1,{0}}, {-1,{0}}, +#line 524 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str562), {226, 167, 165, 0}}, + {-1,{0}}, +#line 1929 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str564), {226, 140, 156, 0}}, + {-1,{0}}, +#line 2054 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str566), {226, 132, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 988 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str571), {226, 167, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 298 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str575), {194, 169, 0}}, + {-1,{0}}, +#line 1928 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str577), {226, 140, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2012 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str582), {226, 138, 187, 0}}, + {-1,{0}}, +#line 1391 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str584), {226, 136, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1729 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str589), {226, 150, 161, 0}}, + {-1,{0}}, +#line 1087 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str591), {226, 137, 142, 0}}, +#line 107 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str592), {226, 132, 172, 0}}, +#line 2055 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str593), {226, 137, 128, 0}}, +#line 1517 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str594), {226, 164, 143, 0}}, +#line 992 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str595), {226, 140, 159, 0}}, +#line 848 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str596), {226, 164, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 143 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str599), {226, 140, 144, 0}}, + {-1,{0}}, +#line 1661 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str601), {59, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1968 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str606), {226, 140, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1217 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str612), {226, 138, 130, 0}}, + {-1,{0}}, +#line 1604 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str614), {240, 157, 149, 163}}, +#line 1475 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str615), {226, 132, 154, 0}}, +#line 979 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str616), {240, 157, 149, 157}}, + {-1,{0}}, +#line 1712 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str618), {240, 157, 149, 164}}, +#line 1967 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str619), {226, 140, 157, 0}}, +#line 1868 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str620), {240, 157, 149, 139}}, +#line 2126 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str621), {226, 132, 164, 0}}, +#line 504 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str622), {240, 157, 149, 150}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1603 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str626), {226, 166, 134, 0}}, +#line 1944 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str627), {240, 157, 149, 166}}, +#line 977 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str628), {226, 166, 133, 0}}, +#line 1869 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str629), {240, 157, 149, 165}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2074 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str635), {240, 157, 149, 143}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1165 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str639), {240, 157, 149, 159}}, + {-1,{0}}, +#line 145 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str641), {240, 157, 149, 147}}, +#line 511 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str642), {207, 181, 0}}, +#line 561 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str643), {198, 146, 0}}, +#line 733 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str644), {196, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 791 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str647), {240, 157, 149, 129}}, + {-1,{0}}, +#line 1134 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str649), {226, 171, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2052 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str653), {240, 157, 149, 142}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1720 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str658), {226, 136, 154, 0}}, +#line 1262 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str659), {226, 138, 132, 0}}, + {-1,{0}}, +#line 1080 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str661), {226, 137, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1223 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str664), {226, 138, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 196 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str667), {194, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1710 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str670), {47, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 460 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str675), {226, 169, 174, 0}}, + {-1,{0}}, +#line 1428 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str677), {240, 157, 149, 161}}, + {-1,{0}}, {-1,{0}}, +#line 369 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str680), {226, 165, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2031 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str685), {240, 157, 149, 141}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1273 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str690), {226, 138, 131, 0}}, +#line 1270 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str691), {226, 138, 133, 0}}, +#line 2002 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str692), {226, 171, 168, 0}}, + {-1,{0}}, +#line 1265 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str694), {226, 138, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1850 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str700), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1136 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str704), {226, 139, 188, 0}}, +#line 1459 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str705), {226, 140, 147, 0}}, +#line 1709 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str706), {226, 167, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 961 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str710), {226, 139, 166, 0}}, + {-1,{0}}, +#line 1708 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str712), {226, 140, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1730 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str717), {226, 150, 161, 0}}, + {-1,{0}}, +#line 2032 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str719), {240, 157, 149, 167}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1925 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str723), {226, 134, 191, 0}}, + {-1,{0}}, +#line 1930 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str725), {226, 140, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 514 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str729), {226, 137, 130, 0}}, +#line 522 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str730), {226, 137, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 485 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str733), {226, 132, 147, 0}}, +#line 1699 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str734), {226, 168, 179, 0}}, +#line 1066 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str735), {226, 136, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 813 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str738), {240, 157, 149, 130}}, + {-1,{0}}, {-1,{0}}, +#line 1695 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str741), {226, 165, 178, 0}}, + {-1,{0}}, +#line 558 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str743), {226, 153, 173, 0}}, + {-1,{0}}, +#line 1064 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str745), {240, 157, 149, 132}}, +#line 1711 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str746), {240, 157, 149, 138}}, +#line 1061 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str747), {226, 128, 166, 0}}, +#line 1596 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str748), {226, 128, 143, 0}}, +#line 767 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str749), {226, 168, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 990 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str756), {226, 166, 147, 0}}, + {-1,{0}}, +#line 563 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str758), {240, 157, 149, 151}}, +#line 1943 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str759), {240, 157, 149, 140}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1995 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str763), {226, 138, 138, 0}}, +#line 1996 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str764), {226, 171, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1969 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str767), {226, 140, 142, 0}}, +#line 927 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str768), {226, 170, 161, 0}}, + {-1,{0}}, +#line 1542 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str770), {226, 132, 156, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1201 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str773), {226, 170, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 395 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str777), {240, 157, 148, 187}}, + {-1,{0}}, +#line 567 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str779), {226, 171, 153, 0}}, + {-1,{0}}, +#line 1260 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str781), {226, 139, 162, 0}}, + {-1,{0}}, +#line 1272 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str783), {226, 138, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1264 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str787), {226, 138, 136, 0}}, +#line 1474 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str788), {240, 157, 149, 162}}, +#line 1595 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str789), {226, 135, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 995 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str792), {226, 128, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1156 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str796), {226, 137, 180, 0}}, + {-1,{0}}, +#line 1430 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str798), {194, 163, 0}}, +#line 1997 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str799), {226, 138, 139, 0}}, +#line 1998 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str800), {226, 171, 140, 0}}, + {-1,{0}}, +#line 141 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str802), {226, 137, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 978 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str813), {240, 157, 149, 131}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1261 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str817), {226, 139, 163, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1506 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str820), {226, 134, 172, 0}}, +#line 2045 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str821), {226, 169, 159, 0}}, +#line 838 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str822), {226, 134, 171, 0}}, + {-1,{0}}, +#line 2100 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str824), {240, 157, 149, 144}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1209 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str829), {226, 136, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 294 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str832), {226, 132, 130, 0}}, +#line 993 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str833), {226, 135, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1390 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str848), {226, 171, 189, 0}}, +#line 1934 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str849), {194, 168, 0}}, +#line 1038 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str850), {226, 150, 174, 0}}, +#line 1274 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str851), {226, 138, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1266 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str855), {226, 138, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1737 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str861), {226, 150, 170, 0}}, +#line 2020 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str862), {226, 128, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1735 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str874), {226, 138, 146, 0}}, + {-1,{0}}, +#line 1464 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str876), {226, 137, 190, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1733 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str879), {226, 138, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1734 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str882), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1732 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str887), {226, 138, 143, 0}}, +#line 1289 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str888), {226, 137, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 764 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str892), {240, 157, 149, 154}}, + {-1,{0}}, +#line 1425 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str894), {194, 177, 0}}, + {-1,{0}}, +#line 2019 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str896), {124, 0}}, + {-1,{0}}, +#line 1844 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str898), {207, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 986 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str901), {226, 151, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1033 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str905), {226, 134, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 922 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str920), {226, 170, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1615 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str934), {240, 157, 147, 135}}, +#line 1477 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str935), {240, 157, 146, 172}}, +#line 998 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str936), {240, 157, 147, 129}}, + {-1,{0}}, +#line 1742 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str938), {240, 157, 147, 136}}, + {-1,{0}}, +#line 1890 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str940), {240, 157, 146, 175}}, +#line 2127 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str941), {240, 157, 146, 181}}, +#line 527 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str942), {226, 132, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1974 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str947), {240, 157, 147, 138}}, + {-1,{0}}, +#line 1891 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str949), {240, 157, 147, 137}}, + {-1,{0}}, +#line 740 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str951), {226, 138, 183, 0}}, +#line 296 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str952), {226, 136, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2080 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str955), {240, 157, 146, 179}}, +#line 2067 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str956), {206, 158, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1252 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str959), {240, 157, 147, 131}}, +#line 1135 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str960), {226, 136, 139, 0}}, +#line 197 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str961), {240, 157, 146, 183}}, +#line 1166 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str962), {226, 132, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 793 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str967), {240, 157, 146, 165}}, +#line 1442 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str968), {226, 170, 175, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1302 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str971), {226, 164, 131, 0}}, +#line 87 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str972), {226, 128, 181, 0}}, +#line 2057 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str973), {240, 157, 146, 178}}, + {-1,{0}}, +#line 1988 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str975), {207, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1258 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str984), {226, 136, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 392 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str991), {226, 140, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1467 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str997), {240, 157, 147, 133}}, +#line 1408 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str998), {207, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2035 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1005), {240, 157, 146, 177}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1112 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1011), {226, 137, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1693 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1021), {226, 137, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1275 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1028), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1267 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1032), {226, 171, 133, 0}}, +#line 440 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1033), {226, 140, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1520 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1038), {125, 0}}, +#line 2036 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1039), {240, 157, 147, 139}}, +#line 850 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1040), {123, 0}}, +#line 396 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1041), {240, 157, 149, 149}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 585 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1049), {226, 129, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 930 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1055), {226, 137, 178, 0}}, + {-1,{0}}, {-1,{0}}, +#line 815 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1058), {240, 157, 146, 166}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1416 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1064), {226, 168, 162, 0}}, +#line 1068 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1065), {226, 132, 179, 0}}, +#line 1741 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1066), {240, 157, 146, 174}}, +#line 1523 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1067), {226, 166, 142, 0}}, + {-1,{0}}, +#line 853 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1069), {226, 166, 143, 0}}, +#line 1518 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1070), {226, 164, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1717 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1073), {226, 138, 147, 0}}, +#line 1503 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1074), {226, 135, 146, 0}}, +#line 142 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1075), {226, 171, 173, 0}}, +#line 835 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1076), {226, 135, 144, 0}}, + {-1,{0}}, +#line 587 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1078), {240, 157, 146, 187}}, +#line 1973 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1079), {240, 157, 146, 176}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1905 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1087), {226, 135, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1605 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1090), {226, 132, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2053 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1094), {240, 157, 149, 168}}, + {-1,{0}}, {-1,{0}}, +#line 442 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1097), {240, 157, 146, 159}}, +#line 1351 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1098), {226, 166, 183, 0}}, +#line 1662 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1099), {226, 164, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 362 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1103), {226, 136, 135, 0}}, +#line 1485 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1104), {226, 135, 155, 0}}, +#line 1558 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1105), {207, 129, 0}}, +#line 817 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1106), {226, 135, 154, 0}}, +#line 1437 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1107), {226, 137, 188, 0}}, +#line 1478 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1108), {240, 157, 147, 134}}, + {-1,{0}}, {-1,{0}}, +#line 1028 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1111), {194, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1185 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1115), {226, 136, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 523 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1120), {226, 169, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1716 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1125), {226, 138, 147, 0}}, + {-1,{0}}, +#line 1259 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1127), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1340 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1131), {226, 167, 128, 0}}, +#line 1514 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1132), {226, 136, 182, 0}}, +#line 999 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1133), {226, 132, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 370 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1137), {226, 135, 131, 0}}, + {-1,{0}}, +#line 393 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1139), {226, 140, 141, 0}}, +#line 408 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1140), {194, 168, 0}}, +#line 404 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1141), {226, 136, 148, 0}}, +#line 1358 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1142), {226, 136, 168, 0}}, + {-1,{0}}, +#line 2102 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1144), {240, 157, 146, 180}}, + {-1,{0}}, {-1,{0}}, +#line 562 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1147), {240, 157, 148, 189}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 304 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1152), {240, 157, 146, 158}}, +#line 1336 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1153), {226, 134, 186, 0}}, +#line 1243 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1154), {226, 134, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1026 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1159), {226, 137, 168, 0}}, +#line 515 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1160), {226, 170, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1853 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1164), {195, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 516 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1169), {226, 170, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 743 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1172), {226, 132, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1992 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1179), {226, 135, 149, 0}}, +#line 1611 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1180), {226, 168, 146, 0}}, +#line 441 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1181), {226, 140, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1387 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1187), {226, 136, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1356 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1195), {226, 134, 187, 0}}, +#line 1744 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1196), {226, 140, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 412 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1200), {226, 171, 164, 0}}, +#line 526 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1201), {226, 137, 147, 0}}, +#line 381 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1202), {226, 153, 166, 0}}, +#line 1743 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1203), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1368 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1208), {226, 147, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 769 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1212), {240, 157, 146, 190}}, +#line 725 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1213), {226, 133, 136, 0}}, +#line 1543 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1214), {226, 150, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1249 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1217), {226, 139, 161, 0}}, +#line 1660 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1218), {194, 167, 0}}, + {-1,{0}}, +#line 1060 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1220), {226, 171, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1365 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1224), {226, 169, 150, 0}}, + {-1,{0}}, +#line 407 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1226), {226, 136, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 518 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1230), {61, 0}}, + {-1,{0}}, +#line 679 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1232), {94, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1745 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1236), {226, 139, 134, 0}}, +#line 1069 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1237), {226, 136, 190, 0}}, + {-1,{0}}, +#line 382 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1239), {194, 168, 0}}, +#line 1044 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1240), {226, 136, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 564 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1252), {226, 136, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1189 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1255), {226, 139, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1065 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1263), {240, 157, 149, 158}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1138 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1270), {226, 136, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2004 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1280), {226, 171, 169, 0}}, + {-1,{0}}, +#line 1251 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1282), {240, 157, 146, 169}}, + {-1,{0}}, +#line 1396 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1284), {46, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 102 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1292), {226, 136, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 112 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1298), {226, 137, 172, 0}}, +#line 750 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1299), {226, 136, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 103 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1307), {226, 136, 181, 0}}, +#line 1410 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1308), {207, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1551 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1326), {240, 157, 148, 175}}, +#line 1471 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1327), {240, 157, 148, 148}}, +#line 934 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1328), {240, 157, 148, 169}}, + {-1,{0}}, +#line 1667 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1330), {240, 157, 148, 176}}, +#line 1148 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1331), {226, 134, 174, 0}}, +#line 1836 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1332), {240, 157, 148, 151}}, +#line 2121 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1333), {226, 132, 168, 0}}, +#line 476 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1334), {240, 157, 148, 162}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1685 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1338), {226, 136, 188, 0}}, +#line 1921 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1339), {240, 157, 148, 178}}, +#line 1606 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1340), {226, 168, 174, 0}}, +#line 1837 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1341), {240, 157, 148, 177}}, +#line 980 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1342), {226, 168, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2063 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1347), {240, 157, 148, 155}}, + {-1,{0}}, {-1,{0}}, +#line 1538 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1350), {226, 132, 156, 0}}, +#line 1119 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1351), {240, 157, 148, 171}}, + {-1,{0}}, +#line 114 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1353), {240, 157, 148, 159}}, + {-1,{0}}, +#line 1184 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1355), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 788 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1359), {240, 157, 148, 141}}, + {-1,{0}}, +#line 443 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1361), {240, 157, 146, 185}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2050 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1365), {240, 157, 148, 154}}, + {-1,{0}}, +#line 129 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1367), {226, 167, 171, 0}}, + {-1,{0}}, +#line 2125 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1369), {240, 157, 149, 171}}, +#line 1541 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1370), {226, 132, 157, 0}}, + {-1,{0}}, +#line 1170 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1372), {226, 137, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1694 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1375), {226, 168, 164, 0}}, + {-1,{0}}, +#line 565 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1377), {226, 136, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1401 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1389), {240, 157, 148, 173}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1342 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1395), {197, 141, 0}}, + {-1,{0}}, +#line 2026 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1397), {240, 157, 148, 153}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 488 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1409), {196, 146, 0}}, +#line 1616 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1410), {226, 132, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2058 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1414), {240, 157, 147, 140}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1679 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1423), {226, 134, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1664 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1429), {226, 136, 150, 0}}, + {-1,{0}}, +#line 2027 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1431), {240, 157, 148, 179}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 806 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1450), {240, 157, 148, 142}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1354 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1455), {226, 166, 185, 0}}, + {-1,{0}}, +#line 1047 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1457), {240, 157, 148, 144}}, +#line 1666 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1458), {240, 157, 148, 150}}, + {-1,{0}}, {-1,{0}}, +#line 1160 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1461), {226, 139, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 588 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1467), {226, 132, 177, 0}}, + {-1,{0}}, {-1,{0}}, +#line 553 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1470), {240, 157, 148, 163}}, +#line 1920 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1471), {240, 157, 148, 152}}, + {-1,{0}}, +#line 1676 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1473), {226, 136, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1304 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1488), {226, 136, 188, 0}}, +#line 367 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1489), {240, 157, 148, 135}}, +#line 920 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1490), {226, 139, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1458 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1493), {226, 140, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1472 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1500), {240, 157, 148, 174}}, +#line 345 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1501), {226, 135, 147, 0}}, + {-1,{0}}, +#line 1247 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1503), {226, 139, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1678 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1507), {226, 134, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1840 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1515), {226, 136, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 357 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1519), {226, 133, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1839 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1524), {226, 136, 180, 0}}, +#line 933 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1525), {240, 157, 148, 143}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1824 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1532), {226, 140, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 483 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1535), {226, 136, 136, 0}}, +#line 2096 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1536), {240, 157, 148, 156}}, +#line 271 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1537), {226, 136, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1337 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1542), {226, 166, 190, 0}}, + {-1,{0}}, +#line 245 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1544), {226, 132, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 548 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1559), {226, 153, 128, 0}}, +#line 1269 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1560), {226, 170, 176, 0}}, +#line 1312 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1561), {226, 138, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1395 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1568), {37, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1362 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1578), {194, 170, 0}}, + {-1,{0}}, +#line 1359 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1580), {226, 169, 157, 0}}, +#line 1557 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1581), {206, 161, 0}}, + {-1,{0}}, +#line 1067 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1583), {240, 157, 147, 130}}, + {-1,{0}}, +#line 1303 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1585), {226, 138, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 958 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1589), {226, 137, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1133 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1597), {226, 135, 142, 0}}, +#line 1357 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1598), {226, 169, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 387 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1602), {195, 183, 0}}, + {-1,{0}}, +#line 721 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1604), {240, 157, 148, 166}}, +#line 484 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1605), {226, 143, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 203 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1615), {92, 0}}, +#line 1298 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1616), {226, 164, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 732 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1626), {196, 170, 0}}, + {-1,{0}}, +#line 89 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1628), {226, 139, 141, 0}}, +#line 1898 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1629), {226, 137, 172, 0}}, +#line 1338 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1630), {226, 166, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1508 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1639), {226, 165, 180, 0}}, +#line 409 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1640), {226, 135, 147, 0}}, +#line 840 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1641), {226, 165, 179, 0}}, +#line 491 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1642), {226, 136, 133, 0}}, +#line 1350 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1643), {240, 157, 149, 160}}, + {-1,{0}}, +#line 540 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1645), {226, 136, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 949 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1648), {226, 165, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 539 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1656), {33, 0}}, +#line 503 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1657), {240, 157, 148, 188}}, +#line 1142 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1658), {226, 135, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1849 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1663), {226, 128, 137, 0}}, +#line 1218 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1664), {226, 138, 136, 0}}, +#line 1403 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1665), {207, 134, 0}}, +#line 410 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1666), {226, 135, 144, 0}}, + {-1,{0}}, +#line 1866 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1668), {226, 171, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 386 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1672), {195, 183, 0}}, + {-1,{0}}, +#line 1118 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1674), {240, 157, 148, 145}}, +#line 1144 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1675), {226, 137, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2128 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1689), {240, 157, 147, 143}}, +#line 994 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1690), {226, 165, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 950 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1697), {226, 151, 186, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1242 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1700), {226, 135, 143, 0}}, +#line 1224 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1701), {226, 138, 137, 0}}, + {-1,{0}}, +#line 1819 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1703), {226, 135, 153, 0}}, +#line 1847 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1704), {226, 129, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1931 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1708), {226, 151, 184, 0}}, +#line 1204 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1709), {226, 139, 190, 0}}, + {-1,{0}}, +#line 1449 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1711), {226, 128, 178, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1451 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1714), {226, 132, 153, 0}}, + {-1,{0}}, +#line 1334 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1716), {206, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 264 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1719), {226, 138, 151, 0}}, +#line 1159 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1720), {226, 139, 170, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1691 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1723), {226, 170, 157, 0}}, +#line 1307 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1724), {226, 135, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1989 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1727), {207, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1367 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1730), {226, 169, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1663 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1735), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 996 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1739), {226, 138, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1397 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1743), {226, 128, 176, 0}}, +#line 1053 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1744), {226, 136, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1972 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1750), {226, 151, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 368 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1753), {240, 157, 148, 161}}, +#line 1049 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1754), {226, 132, 167, 0}}, +#line 1447 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1755), {226, 170, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2040 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1759), {226, 138, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1246 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1762), {226, 139, 171, 0}}, +#line 2038 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1763), {226, 138, 138, 0}}, + {-1,{0}}, +#line 472 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1765), {226, 137, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 918 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1778), {226, 170, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 86 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1781), {207, 182, 0}}, + {-1,{0}}, +#line 1512 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1783), {226, 164, 154, 0}}, + {-1,{0}}, +#line 842 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1785), {226, 164, 153, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1953 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1788), {226, 165, 174, 0}}, + {-1,{0}}, {-1,{0}}, +#line 510 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1791), {206, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1963 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1796), {207, 133, 0}}, + {-1,{0}}, +#line 1051 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1798), {42, 0}}, +#line 697 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1799), {226, 132, 141, 0}}, +#line 2028 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1800), {226, 138, 178, 0}}, + {-1,{0}}, +#line 1552 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1802), {226, 132, 156, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2047 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1805), {226, 139, 128, 0}}, +#line 2051 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1806), {240, 157, 148, 180}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 93 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1812), {226, 140, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1030 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1815), {226, 156, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 250 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1820), {206, 167, 0}}, +#line 493 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1821), {226, 136, 133, 0}}, +#line 1202 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1822), {226, 136, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 925 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1827), {226, 137, 182, 0}}, + {-1,{0}}, +#line 377 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1829), {226, 139, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2034 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1842), {226, 138, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 262 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1849), {226, 138, 150, 0}}, + {-1,{0}}, +#line 1341 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1851), {197, 140, 0}}, +#line 1658 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1852), {226, 135, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 552 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1859), {240, 157, 148, 137}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1444 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1865), {226, 170, 181, 0}}, + {-1,{0}}, +#line 379 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1867), {226, 139, 132, 0}}, +#line 1363 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1868), {194, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1102 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1873), {226, 135, 151, 0}}, +#line 763 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1874), {240, 157, 149, 128}}, +#line 259 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1875), {226, 138, 153, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1452 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1878), {226, 170, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 403 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1884), {226, 136, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1253 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1903), {226, 136, 164, 0}}, + {-1,{0}}, +#line 147 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1905), {226, 138, 165, 0}}, + {-1,{0}}, +#line 1427 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1907), {226, 168, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1736 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1917), {226, 138, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 792 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1925), {240, 157, 149, 155}}, + {-1,{0}}, {-1,{0}}, +#line 1962 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1928), {206, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 278 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1936), {226, 169, 180, 0}}, + {-1,{0}}, +#line 1300 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1938), {60, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1114 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1941), {226, 137, 170, 0}}, +#line 277 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1942), {226, 136, 183, 0}}, + {-1,{0}}, {-1,{0}}, +#line 204 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1945), {226, 159, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 411 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1949), {226, 135, 148, 0}}, +#line 1423 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1950), {226, 168, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 734 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1959), {226, 132, 145, 0}}, +#line 480 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1960), {226, 170, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1370 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1963), {226, 132, 180, 0}}, +#line 1821 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1964), {226, 164, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2116 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1969), {226, 132, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1031 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1973), {226, 156, 160, 0}}, + {-1,{0}}, +#line 1048 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1975), {240, 157, 148, 170}}, +#line 1504 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1976), {226, 164, 158, 0}}, +#line 528 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1977), {226, 132, 176, 0}}, +#line 836 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1978), {226, 164, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1062 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1985), {226, 136, 147, 0}}, +#line 1129 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1986), {226, 137, 175, 0}}, +#line 1130 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1987), {226, 137, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 627 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str1996), {226, 137, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 380 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2003), {226, 153, 166, 0}}, +#line 655 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2004), {62, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 928 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2014), {226, 137, 178, 0}}, +#line 446 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2015), {226, 167, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1954 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2023), {226, 134, 191, 0}}, +#line 1731 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2024), {226, 138, 147, 0}}, +#line 1003 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2025), {226, 170, 141, 0}}, + {-1,{0}}, +#line 1157 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2027), {226, 137, 170, 0}}, + {-1,{0}}, +#line 1194 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2029), {226, 137, 174, 0}}, + {-1,{0}}, +#line 630 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2031), {226, 170, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1634 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2035), {226, 170, 184, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1036 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2038), {226, 134, 164, 0}}, +#line 1197 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2039), {226, 137, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1550 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2043), {226, 140, 139, 0}}, + {-1,{0}}, +#line 932 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2045), {226, 140, 138, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1256 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2048), {226, 137, 132, 0}}, + {-1,{0}}, +#line 201 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2050), {226, 139, 141, 0}}, +#line 1195 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2051), {226, 137, 176, 0}}, +#line 1199 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2052), {226, 137, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1089 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2056), {226, 169, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1196 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2059), {226, 137, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1448 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2070), {226, 137, 190, 0}}, + {-1,{0}}, +#line 976 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2072), {226, 134, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1432 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2076), {226, 170, 187, 0}}, +#line 1530 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2077), {125, 0}}, +#line 1037 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2078), {226, 134, 165, 0}}, +#line 860 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2079), {123, 0}}, + {-1,{0}}, +#line 2120 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2081), {240, 157, 148, 183}}, + {-1,{0}}, {-1,{0}}, +#line 1946 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2084), {226, 134, 145, 0}}, + {-1,{0}}, +#line 632 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2086), {226, 170, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1640 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2090), {226, 170, 176, 0}}, +#line 739 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2091), {226, 132, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1526 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2096), {197, 153, 0}}, + {-1,{0}}, +#line 856 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2098), {196, 190, 0}}, +#line 1349 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2099), {240, 157, 149, 134}}, +#line 1636 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2100), {197, 161, 0}}, +#line 88 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2101), {226, 136, 189, 0}}, +#line 1828 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2102), {197, 164, 0}}, +#line 2110 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2103), {197, 189, 0}}, +#line 462 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2104), {196, 155, 0}}, + {-1,{0}}, +#line 108 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2106), {226, 132, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1121 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2110), {226, 137, 177, 0}}, +#line 1829 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2111), {197, 165, 0}}, + {-1,{0}}, +#line 566 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2113), {226, 139, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 701 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2119), {226, 132, 139, 0}}, + {-1,{0}}, +#line 1091 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2121), {197, 136, 0}}, +#line 487 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2122), {226, 170, 151, 0}}, + {-1,{0}}, +#line 1827 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2124), {226, 142, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1886 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2128), {226, 168, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 378 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2131), {226, 139, 132, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1096 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2134), {226, 169, 130, 0}}, + {-1,{0}}, +#line 96 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2136), {226, 142, 181, 0}}, + {-1,{0}}, +#line 586 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2138), {226, 140, 162, 0}}, +#line 128 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2139), {226, 164, 141, 0}}, + {-1,{0}}, +#line 1713 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2141), {226, 153, 160, 0}}, + {-1,{0}}, +#line 1469 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2143), {207, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 144 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2150), {240, 157, 148, 185}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 394 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2156), {36, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 385 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2164), {226, 139, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1714 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2170), {226, 153, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1225 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2176), {226, 137, 129, 0}}, +#line 406 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2177), {226, 140, 134, 0}}, + {-1,{0}}, +#line 594 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2179), {226, 170, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 97 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2186), {226, 142, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1820 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2189), {226, 134, 153, 0}}, +#line 106 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2190), {207, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 770 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2194), {226, 132, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1227 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2198), {226, 137, 135, 0}}, +#line 513 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2199), {226, 137, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1863 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2202), {226, 136, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 756 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2205), {226, 168, 188, 0}}, + {-1,{0}}, +#line 1271 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2207), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1308 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2210), {226, 134, 150, 0}}, +#line 1263 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2211), {226, 171, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1125 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2214), {226, 169, 190, 0}}, + {-1,{0}}, +#line 1948 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2216), {226, 135, 145, 0}}, +#line 604 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2217), {226, 137, 165, 0}}, +#line 1352 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2218), {226, 128, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1698 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2223), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1635 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2228), {197, 160, 0}}, + {-1,{0}}, +#line 1301 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2230), {226, 138, 180, 0}}, +#line 612 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2231), {226, 169, 190, 0}}, +#line 135 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2232), {226, 144, 163, 0}}, +#line 1484 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2233), {34, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 139 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2238), {226, 150, 136, 0}}, +#line 1873 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2239), {226, 132, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 794 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2245), {240, 157, 146, 191}}, +#line 2046 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2246), {226, 136, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 29 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2254), {196, 128, 0}}, + {-1,{0}}, +#line 517 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2256), {226, 169, 181, 0}}, + {-1,{0}}, {-1,{0}}, +#line 351 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2259), {196, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 399 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2262), {226, 131, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 634 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2270), {226, 170, 136, 0}}, +#line 1990 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2271), {226, 136, 157, 0}}, + {-1,{0}}, +#line 635 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2273), {226, 137, 169, 0}}, +#line 1461 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2274), {226, 136, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 774 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2279), {226, 139, 180, 0}}, + {-1,{0}}, +#line 469 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2281), {226, 169, 183, 0}}, +#line 771 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2282), {226, 136, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1885 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2286), {226, 131, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 568 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2290), {226, 132, 177, 0}}, +#line 1462 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2291), {226, 136, 183, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1122 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2294), {226, 137, 177, 0}}, +#line 855 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2295), {196, 189, 0}}, + {-1,{0}}, +#line 1123 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2297), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 870 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2313), {226, 137, 166, 0}}, +#line 227 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2314), {196, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 199 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2320), {226, 129, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1463 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2326), {226, 136, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 914 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2331), {226, 169, 191, 0}}, +#line 291 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2332), {226, 136, 175, 0}}, + {-1,{0}}, +#line 35 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2334), {226, 169, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1659 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2338), {226, 134, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1366 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2343), {226, 169, 151, 0}}, +#line 676 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2344), {226, 134, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 845 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2350), {226, 170, 173, 0}}, + {-1,{0}}, +#line 243 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2352), {194, 183, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1328 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2355), {240, 157, 148, 172}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1103 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2359), {226, 134, 151, 0}}, + {-1,{0}}, +#line 1473 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2361), {226, 168, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 846 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2364), {226, 170, 173, 0}}, +#line 801 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2365), {207, 176, 0}}, + {-1,{0}}, {-1,{0}}, +#line 698 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2368), {226, 128, 149, 0}}, +#line 475 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2369), {240, 157, 148, 136}}, +#line 692 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2370), {226, 135, 191, 0}}, +#line 1239 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2371), {226, 170, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 747 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2377), {196, 177, 0}}, + {-1,{0}}, +#line 1915 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2379), {226, 135, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 608 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2386), {226, 137, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1257 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2391), {226, 137, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 609 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2404), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, +#line 474 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2407), {226, 137, 146, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1610 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2410), {226, 166, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1369 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2419), {240, 157, 146, 170}}, + {-1,{0}}, {-1,{0}}, +#line 1418 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2422), {226, 136, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 821 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2425), {226, 132, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1846 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2429), {226, 136, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1445 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2440), {226, 139, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1090 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2444), {197, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1079 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2449), {226, 169, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 727 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2457), {226, 136, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 198 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2470), {226, 132, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1035 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2483), {226, 134, 167, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1993 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2486), {207, 177, 0}}, + {-1,{0}}, +#line 775 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2488), {226, 139, 179, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1296 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2491), {226, 164, 132, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1191 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2494), {226, 167, 143, 0}}, + {-1,{0}}, +#line 520 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2496), {226, 137, 159, 0}}, + {-1,{0}}, +#line 1193 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2498), {226, 139, 172, 0}}, +#line 1192 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2499), {226, 139, 170, 0}}, + {-1,{0}}, {-1,{0}}, +#line 60 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2502), {240, 157, 148, 184}}, +#line 680 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2503), {226, 132, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1984 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2507), {226, 166, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 688 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2511), {226, 132, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1494 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2517), {226, 166, 165, 0}}, +#line 1704 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2518), {226, 170, 172, 0}}, +#line 1002 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2519), {226, 137, 178, 0}}, + {-1,{0}}, +#line 1234 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2521), {226, 168, 148, 0}}, + {-1,{0}}, +#line 352 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2523), {196, 143, 0}}, + {-1,{0}}, +#line 531 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2525), {226, 137, 130, 0}}, + {-1,{0}}, +#line 1939 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2527), {226, 139, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1705 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2532), {226, 170, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 814 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2536), {240, 157, 149, 156}}, +#line 638 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2537), {240, 157, 149, 152}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1255 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2542), {226, 137, 129, 0}}, + {-1,{0}}, +#line 200 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2544), {226, 136, 189, 0}}, + {-1,{0}}, +#line 1697 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2546), {226, 136, 152, 0}}, + {-1,{0}}, +#line 1171 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2548), {226, 136, 166, 0}}, +#line 1200 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2549), {226, 170, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 519 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2565), {226, 137, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1186 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2568), {226, 139, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1525 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2572), {197, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1429 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2577), {226, 132, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 637 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2583), {240, 157, 148, 190}}, + {-1,{0}}, {-1,{0}}, +#line 722 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2586), {226, 132, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2048 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2589), {226, 137, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1455 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2595), {226, 136, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1373 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2617), {226, 138, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 418 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2624), {226, 135, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 289 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2627), {226, 137, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 636 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2631), {226, 139, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1650 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2635), {226, 137, 191, 0}}, + {-1,{0}}, +#line 789 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2637), {240, 157, 148, 167}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1961 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2645), {207, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1155 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2650), {226, 139, 152, 0}}, + {-1,{0}}, {-1,{0}}, +#line 419 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2653), {226, 135, 149, 0}}, + {-1,{0}}, +#line 1127 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2655), {226, 137, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 683 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2664), {226, 153, 165, 0}}, + {-1,{0}}, +#line 921 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2666), {226, 139, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1111 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2670), {226, 164, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 541 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2676), {226, 136, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1702 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2687), {226, 140, 163, 0}}, + {-1,{0}}, +#line 1983 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2689), {226, 166, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 684 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2693), {226, 153, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 699 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2700), {226, 148, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 644 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2703), {226, 137, 183, 0}}, + {-1,{0}}, +#line 1614 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2705), {226, 128, 186, 0}}, + {-1,{0}}, +#line 997 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2707), {226, 128, 185, 0}}, + {-1,{0}}, +#line 1539 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2709), {226, 132, 155, 0}}, +#line 347 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2710), {226, 171, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1686 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2714), {226, 169, 170, 0}}, +#line 640 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2715), {226, 137, 165, 0}}, +#line 646 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2716), {226, 137, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 641 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2721), {226, 139, 155, 0}}, + {-1,{0}}, +#line 643 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2723), {226, 170, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1529 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2737), {226, 140, 137, 0}}, + {-1,{0}}, +#line 859 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2739), {226, 140, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 926 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2743), {226, 137, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1339 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2746), {226, 128, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1851 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2753), {226, 136, 188, 0}}, + {-1,{0}}, +#line 758 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2755), {226, 129, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1486 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2762), {226, 136, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 768 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2766), {194, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 736 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2774), {226, 132, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1965 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2779), {226, 138, 165, 0}}, + {-1,{0}}, +#line 1052 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2781), {226, 171, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1326 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2790), {226, 166, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 356 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2793), {226, 135, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1493 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2800), {226, 166, 146, 0}}, + {-1,{0}}, +#line 826 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2802), {226, 166, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 521 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2808), {226, 135, 140, 0}}, +#line 1389 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2809), {226, 171, 179, 0}}, +#line 2011 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2810), {226, 171, 166, 0}}, +#line 1327 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2811), {240, 157, 148, 146}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 104 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2816), {226, 136, 181, 0}}, + {-1,{0}}, +#line 1513 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2818), {226, 164, 156, 0}}, + {-1,{0}}, +#line 843 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2820), {226, 164, 155, 0}}, +#line 1348 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2821), {226, 138, 150, 0}}, +#line 73 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2822), {240, 157, 146, 156}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 509 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2826), {206, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1675 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2832), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 776 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2845), {226, 136, 136, 0}}, + {-1,{0}}, +#line 1050 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2847), {194, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2111 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2851), {197, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 816 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2856), {240, 157, 147, 128}}, +#line 648 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2857), {226, 132, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 113 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2862), {240, 157, 148, 133}}, +#line 607 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2863), {226, 139, 155, 0}}, +#line 686 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2864), {226, 138, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1884 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2871), {226, 168, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 479 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2877), {195, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1654 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2881), {226, 139, 133, 0}}, +#line 1923 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2882), {195, 185, 0}}, + {-1,{0}}, +#line 2114 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2884), {197, 187, 0}}, +#line 471 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2885), {196, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1228 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2890), {226, 137, 137, 0}}, + {-1,{0}}, +#line 1834 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2892), {226, 131, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1466 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2897), {240, 157, 146, 171}}, +#line 1407 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2898), {206, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 647 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2903), {240, 157, 146, 162}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1424 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2910), {226, 168, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1172 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2914), {226, 136, 137, 0}}, + {-1,{0}}, +#line 1421 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2916), {194, 177, 0}}, + {-1,{0}}, {-1,{0}}, +#line 696 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2919), {240, 157, 149, 153}}, +#line 593 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2920), {207, 157, 0}}, + {-1,{0}}, +#line 1043 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2922), {226, 136, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 388 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2926), {226, 139, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 400 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2940), {226, 137, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1985 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2956), {207, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1438 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2963), {226, 137, 186, 0}}, + {-1,{0}}, {-1,{0}}, +#line 592 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2966), {207, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 348 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2974), {226, 138, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1169 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2979), {226, 137, 162, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1910 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2982), {197, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1332 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2990), {226, 167, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1608 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str2994), {226, 165, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1440 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3002), {226, 137, 188, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1687 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3005), {226, 137, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1922 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3014), {195, 153, 0}}, + {-1,{0}}, +#line 349 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3016), {226, 164, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1655 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3021), {226, 169, 166, 0}}, + {-1,{0}}, +#line 2015 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3023), {226, 137, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1034 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3027), {226, 134, 166, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1861 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3030), {195, 151, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1495 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3033), {226, 159, 169, 0}}, + {-1,{0}}, +#line 827 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3035), {226, 159, 168, 0}}, + {-1,{0}}, {-1,{0}}, +#line 877 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3038), {226, 134, 162, 0}}, +#line 672 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3039), {226, 132, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1918 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3044), {226, 165, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1137 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3053), {226, 139, 186, 0}}, + {-1,{0}}, +#line 1549 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3055), {226, 165, 189, 0}}, + {-1,{0}}, +#line 931 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3057), {226, 165, 188, 0}}, +#line 675 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3058), {226, 165, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1353 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3066), {226, 128, 152, 0}}, + {-1,{0}}, +#line 1919 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3068), {226, 165, 190, 0}}, +#line 1183 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3069), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, +#line 895 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3072), {226, 138, 163, 0}}, + {-1,{0}}, +#line 1617 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3074), {226, 134, 177, 0}}, + {-1,{0}}, +#line 1000 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3076), {226, 134, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 667 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3080), {226, 137, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1860 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3083), {226, 138, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1649 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3092), {226, 168, 147, 0}}, + {-1,{0}}, {-1,{0}}, +#line 236 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3095), {196, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 454 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3103), {226, 166, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1909 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3114), {197, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 904 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3132), {226, 134, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 903 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3135), {226, 165, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 461 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3139), {196, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 693 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3142), {226, 136, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 724 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3147), {195, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1238 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3155), {226, 170, 175, 0}}, +#line 466 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3156), {226, 137, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 358 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3167), {226, 133, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1688 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3174), {226, 137, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1187 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3179), {226, 139, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 119 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3198), {226, 168, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 21 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3214), {240, 157, 148, 132}}, +#line 873 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3215), {226, 134, 144, 0}}, +#line 1335 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3216), {226, 136, 174, 0}}, + {-1,{0}}, +#line 1823 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3218), {9, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1329 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3227), {203, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1012 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3230), {60, 0}}, +#line 1149 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3231), {226, 135, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1498 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3235), {226, 135, 165, 0}}, + {-1,{0}}, +#line 831 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3237), {226, 135, 164, 0}}, + {-1,{0}}, +#line 700 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3239), {240, 157, 146, 189}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 901 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3246), {226, 165, 145, 0}}, + {-1,{0}}, +#line 807 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3248), {240, 157, 148, 168}}, +#line 619 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3249), {240, 157, 148, 164}}, +#line 1945 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3250), {226, 164, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1250 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3259), {226, 170, 176, 0}}, +#line 1015 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3260), {226, 139, 150, 0}}, +#line 616 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3261), {226, 139, 155, 0}}, +#line 2073 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3262), {226, 168, 128, 0}}, +#line 1747 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3263), {226, 152, 134, 0}}, + {-1,{0}}, {-1,{0}}, +#line 983 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3266), {95, 0}}, + {-1,{0}}, +#line 2065 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3268), {226, 159, 183, 0}}, +#line 465 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3269), {226, 137, 150, 0}}, + {-1,{0}}, +#line 1975 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3271), {226, 139, 176, 0}}, +#line 1085 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3272), {226, 153, 174, 0}}, +#line 1001 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3273), {226, 134, 176, 0}}, +#line 745 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3274), {226, 136, 158, 0}}, + {-1,{0}}, +#line 283 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3276), {226, 136, 129, 0}}, + {-1,{0}}, +#line 1684 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3278), {207, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2077 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3285), {226, 168, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1400 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3289), {240, 157, 148, 147}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 618 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3295), {240, 157, 148, 138}}, + {-1,{0}}, {-1,{0}}, +#line 115 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3298), {226, 139, 130, 0}}, + {-1,{0}}, +#line 1692 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3300), {226, 170, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 726 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3319), {226, 168, 140, 0}}, +#line 95 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3320), {226, 140, 133, 0}}, +#line 94 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3321), {226, 140, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2069 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3329), {226, 159, 181, 0}}, +#line 923 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3330), {226, 139, 154, 0}}, + {-1,{0}}, +#line 301 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3332), {226, 134, 181, 0}}, +#line 772 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3333), {226, 139, 181, 0}}, + {-1,{0}}, +#line 282 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3335), {64, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1054 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3342), {194, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 916 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3349), {226, 170, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1683 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3356), {207, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1499 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3366), {226, 164, 160, 0}}, + {-1,{0}}, +#line 832 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3368), {226, 164, 159, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2078 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3371), {226, 159, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 117 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3376), {226, 139, 131, 0}}, + {-1,{0}}, +#line 274 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3378), {226, 153, 163, 0}}, +#line 677 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3379), {226, 135, 148, 0}}, +#line 1625 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3380), {226, 138, 181, 0}}, + {-1,{0}}, +#line 1021 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3382), {226, 138, 180, 0}}, +#line 741 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3383), {198, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 502 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3388), {196, 153, 0}}, +#line 1630 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3389), {226, 132, 158, 0}}, +#line 1023 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3390), {226, 166, 150, 0}}, +#line 1746 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3391), {226, 139, 134, 0}}, + {-1,{0}}, +#line 1942 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3393), {197, 179, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1855 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3396), {226, 136, 188, 0}}, + {-1,{0}}, +#line 671 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3398), {194, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1854 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3405), {203, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 875 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3412), {226, 135, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 617 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3417), {226, 170, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 217 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3422), {226, 136, 169, 0}}, +#line 1751 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3423), {194, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1014 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3427), {226, 137, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1453 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3439), {226, 170, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1726 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3447), {226, 138, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1727 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3462), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1882 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3467), {226, 151, 172, 0}}, +#line 1360 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3468), {226, 132, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 222 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3471), {226, 136, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 302 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3475), {226, 156, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 366 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3482), {226, 165, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2071 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3487), {226, 159, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1725 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3491), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1624 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3503), {226, 150, 185, 0}}, + {-1,{0}}, +#line 1020 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3505), {226, 151, 131, 0}}, +#line 777 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3506), {226, 129, 162, 0}}, +#line 1598 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3507), {226, 142, 177, 0}}, + {-1,{0}}, +#line 954 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3509), {226, 142, 176, 0}}, +#line 633 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3510), {226, 137, 169, 0}}, +#line 936 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3511), {226, 170, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1641 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3514), {226, 170, 180, 0}}, + {-1,{0}}, +#line 1978 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3516), {226, 150, 181, 0}}, + {-1,{0}}, +#line 2016 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3518), {226, 139, 174, 0}}, + {-1,{0}}, +#line 534 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3520), {195, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 952 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3523), {197, 128, 0}}, + {-1,{0}}, +#line 1941 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3525), {197, 178, 0}}, +#line 300 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3526), {226, 136, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1120 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3534), {226, 137, 167, 0}}, +#line 1309 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3535), {226, 164, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 917 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3543), {226, 139, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1415 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3546), {226, 138, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1618 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3550), {226, 134, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 299 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3555), {226, 132, 151, 0}}, + {-1,{0}}, +#line 746 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3557), {226, 167, 157, 0}}, + {-1,{0}}, +#line 738 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3559), {196, 177, 0}}, +#line 530 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3560), {226, 169, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1402 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3565), {206, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 628 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3573), {226, 170, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2030 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3579), {226, 138, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1690 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3582), {226, 170, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 413 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3586), {226, 159, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 414 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3591), {226, 159, 186, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1295 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3594), {62, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1046 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3607), {226, 132, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1450 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3611), {226, 128, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 728 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3615), {226, 167, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1546 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3620), {226, 136, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 492 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3627), {226, 151, 187, 0}}, +#line 1489 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3628), {226, 136, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 687 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3631), {240, 157, 148, 165}}, +#line 2115 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3632), {197, 188, 0}}, +#line 1029 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3633), {226, 153, 130, 0}}, + {-1,{0}}, +#line 1500 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3635), {226, 164, 179, 0}}, +#line 1436 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3636), {226, 137, 186, 0}}, +#line 1646 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3637), {226, 170, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 383 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3641), {226, 133, 134, 0}}, + {-1,{0}}, +#line 1063 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3643), {226, 138, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1011 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3657), {226, 169, 185, 0}}, +#line 762 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3658), {196, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 216 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3665), {226, 169, 139, 0}}, + {-1,{0}}, +#line 720 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3667), {226, 135, 148, 0}}, + {-1,{0}}, +#line 360 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3669), {226, 169, 183, 0}}, + {-1,{0}}, +#line 263 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3671), {226, 138, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1622 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3676), {226, 139, 140, 0}}, + {-1,{0}}, +#line 1016 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3678), {226, 139, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1441 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3681), {226, 137, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 449 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3685), {226, 139, 177, 0}}, + {-1,{0}}, +#line 275 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3687), {226, 153, 163, 0}}, + {-1,{0}}, +#line 1488 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3689), {197, 149, 0}}, + {-1,{0}}, +#line 819 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3691), {196, 186, 0}}, +#line 1889 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3692), {226, 143, 162, 0}}, +#line 1632 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3693), {197, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2108 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3696), {197, 185, 0}}, +#line 459 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3697), {195, 169, 0}}, + {-1,{0}}, +#line 1858 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3699), {226, 137, 136, 0}}, + {-1,{0}}, +#line 1906 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3701), {226, 165, 137, 0}}, +#line 1902 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3702), {195, 186, 0}}, +#line 982 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3703), {226, 136, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1076 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3714), {197, 132, 0}}, + {-1,{0}}, +#line 1206 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3716), {226, 138, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 951 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3720), {196, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1947 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3725), {226, 134, 145, 0}}, + {-1,{0}}, +#line 1511 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3727), {226, 134, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 438 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3738), {226, 138, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 555 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3742), {226, 151, 188, 0}}, +#line 219 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3743), {226, 169, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 642 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3749), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1299 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3756), {226, 137, 164, 0}}, + {-1,{0}}, +#line 1883 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3758), {226, 137, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1346 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3764), {206, 191, 0}}, + {-1,{0}}, +#line 417 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3766), {226, 138, 168, 0}}, +#line 233 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3767), {226, 136, 176, 0}}, +#line 1621 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3768), {226, 128, 153, 0}}, + {-1,{0}}, +#line 1007 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3770), {226, 128, 154, 0}}, + {-1,{0}}, +#line 2124 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3772), {226, 135, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 293 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3780), {240, 157, 149, 148}}, + {-1,{0}}, +#line 292 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3782), {226, 136, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 670 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3798), {226, 128, 138, 0}}, +#line 1728 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3799), {226, 138, 146, 0}}, +#line 306 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3800), {226, 171, 143, 0}}, +#line 1955 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3801), {226, 134, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 426 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3805), {204, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1674 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3817), {226, 134, 147, 0}}, + {-1,{0}}, +#line 2075 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3819), {240, 157, 149, 169}}, + {-1,{0}}, +#line 1631 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3821), {197, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2039 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3829), {226, 171, 140, 0}}, +#line 265 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3830), {226, 151, 139, 0}}, +#line 1414 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3831), {226, 168, 163, 0}}, +#line 308 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3832), {226, 171, 144, 0}}, +#line 2037 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3833), {226, 171, 139, 0}}, +#line 1901 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3834), {195, 154, 0}}, + {-1,{0}}, +#line 773 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3836), {226, 139, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 606 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3845), {226, 170, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1719 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3851), {226, 138, 148, 0}}, + {-1,{0}}, +#line 1701 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3853), {226, 136, 163, 0}}, + {-1,{0}}, +#line 935 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3855), {226, 137, 182, 0}}, + {-1,{0}}, +#line 415 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3857), {226, 159, 185, 0}}, +#line 1208 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3858), {226, 139, 160, 0}}, + {-1,{0}}, {-1,{0}}, +#line 477 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3861), {226, 170, 154, 0}}, + {-1,{0}}, {-1,{0}}, +#line 33 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3864), {38, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1162 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3874), {226, 136, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1862 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3883), {226, 168, 176, 0}}, + {-1,{0}}, {-1,{0}}, +#line 433 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3886), {226, 134, 189, 0}}, +#line 2130 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3887), {226, 128, 140, 0}}, +#line 818 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3888), {196, 185, 0}}, +#line 432 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3889), {226, 165, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1331 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3898), {195, 178, 0}}, +#line 2087 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3899), {195, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1718 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3903), {226, 138, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1322 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3906), {226, 138, 153, 0}}, +#line 212 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3907), {196, 134, 0}}, + {-1,{0}}, +#line 1285 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3909), {206, 189, 0}}, +#line 1888 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3910), {226, 168, 187, 0}}, + {-1,{0}}, +#line 478 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3912), {195, 136, 0}}, +#line 507 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3913), {226, 169, 177, 0}}, + {-1,{0}}, +#line 85 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3915), {226, 137, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1956 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3918), {226, 138, 142, 0}}, + {-1,{0}}, +#line 470 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3920), {196, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 309 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3924), {226, 171, 146, 0}}, + {-1,{0}}, +#line 1689 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3926), {226, 170, 158, 0}}, +#line 1958 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3927), {226, 134, 151, 0}}, +#line 307 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3928), {226, 171, 145, 0}}, + {-1,{0}}, +#line 450 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3930), {226, 150, 191, 0}}, +#line 1454 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3931), {226, 139, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 177 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3936), {226, 149, 153, 0}}, +#line 1980 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3937), {226, 135, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 431 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3945), {226, 165, 158, 0}}, +#line 650 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3946), {226, 170, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 120 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3950), {226, 168, 130, 0}}, +#line 341 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3951), {226, 128, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 754 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3954), {226, 139, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 710 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3967), {195, 173, 0}}, + {-1,{0}}, +#line 1434 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3969), {226, 137, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 481 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3981), {226, 170, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 742 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3987), {226, 135, 146, 0}}, +#line 2010 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3988), {226, 138, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 207 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str3996), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1070 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4015), {206, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2008 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4022), {226, 138, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1027 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4028), {226, 137, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 894 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4033), {226, 134, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1075 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4037), {197, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1936 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4042), {226, 143, 159, 0}}, +#line 1468 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4043), {206, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1559 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4047), {207, 177, 0}}, + {-1,{0}}, +#line 912 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4049), {226, 170, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1789 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4055), {194, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1790 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4058), {194, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1791 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4066), {194, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 118 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4071), {226, 168, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 424 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4078), {226, 135, 147, 0}}, + {-1,{0}}, +#line 2082 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4080), {226, 168, 134, 0}}, + {-1,{0}}, +#line 92 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4082), {226, 138, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1106 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4087), {226, 128, 139, 0}}, +#line 209 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4088), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 305 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4100), {240, 157, 146, 184}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1248 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4109), {226, 138, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1792 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4115), {226, 138, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 238 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4122), {194, 184, 0}}, + {-1,{0}}, {-1,{0}}, +#line 191 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4125), {226, 149, 159, 0}}, + {-1,{0}}, +#line 1364 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4127), {226, 138, 182, 0}}, +#line 2129 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4128), {226, 128, 141, 0}}, +#line 723 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4129), {195, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 716 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4137), {196, 176, 0}}, + {-1,{0}}, +#line 2081 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4139), {240, 157, 147, 141}}, +#line 2068 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4140), {206, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1131 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4144), {226, 137, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 165 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4153), {226, 149, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1852 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4163), {195, 158, 0}}, + {-1,{0}}, +#line 1487 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4165), {197, 148, 0}}, + {-1,{0}}, +#line 1505 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4167), {226, 134, 170, 0}}, + {-1,{0}}, +#line 837 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4169), {226, 134, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1627 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4177), {226, 167, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 180 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4189), {226, 149, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 340 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4215), {226, 128, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1345 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4220), {206, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 420 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4226), {226, 136, 165, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1117 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4229), {226, 136, 132, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1284 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4232), {206, 157, 0}}, +#line 1116 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4233), {226, 136, 132, 0}}, +#line 605 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4234), {226, 137, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 63 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4238), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1793 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4243), {226, 139, 145, 0}}, +#line 401 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4244), {226, 137, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 499 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4247), {197, 139, 0}}, + {-1,{0}}, +#line 224 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4249), {203, 135, 0}}, + {-1,{0}}, +#line 167 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4251), {226, 149, 169, 0}}, +#line 613 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4252), {226, 170, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1547 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4257), {226, 135, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 174 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4262), {226, 149, 157, 0}}, + {-1,{0}}, +#line 1804 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4264), {226, 171, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1409 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4267), {226, 139, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1288 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4272), {226, 128, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1491 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4285), {226, 159, 169, 0}}, + {-1,{0}}, +#line 824 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4287), {226, 159, 168, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1315 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4290), {226, 138, 154, 0}}, + {-1,{0}}, +#line 1515 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4292), {226, 132, 154, 0}}, + {-1,{0}}, +#line 295 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4294), {226, 136, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1018 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4307), {226, 165, 182, 0}}, +#line 194 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4308), {203, 152, 0}}, + {-1,{0}}, +#line 1077 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4310), {226, 136, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1817 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4315), {226, 164, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1496 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4322), {194, 187, 0}}, + {-1,{0}}, +#line 830 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4324), {194, 171, 0}}, +#line 1815 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4325), {226, 171, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 321 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4329), {226, 139, 147, 0}}, +#line 65 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4330), {226, 137, 138, 0}}, +#line 1481 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4331), {63, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1305 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4336), {226, 164, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1808 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4340), {226, 138, 131, 0}}, + {-1,{0}}, +#line 422 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4342), {226, 134, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 452 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4351), {226, 135, 181, 0}}, + {-1,{0}}, +#line 67 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4353), {39, 0}}, +#line 1330 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4354), {195, 146, 0}}, +#line 1677 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4355), {226, 136, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1268 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4364), {226, 138, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 966 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4368), {226, 159, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 915 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4377), {226, 170, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1806 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4384), {226, 138, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1126 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4388), {226, 139, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1490 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4396), {226, 166, 179, 0}}, +#line 1816 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4397), {226, 171, 150, 0}}, +#line 820 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4398), {226, 166, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1870 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4401), {226, 171, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 501 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4423), {196, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1593 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4429), {226, 137, 147, 0}}, + {-1,{0}}, +#line 211 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4431), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1009 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4435), {197, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1896 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4439), {197, 166, 0}}, +#line 649 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4440), {226, 137, 179, 0}}, + {-1,{0}}, {-1,{0}}, +#line 105 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4443), {226, 166, 176, 0}}, +#line 2109 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4444), {197, 186, 0}}, +#line 651 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4445), {226, 170, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1897 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4448), {197, 167, 0}}, + {-1,{0}}, +#line 1600 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4450), {226, 159, 173, 0}}, +#line 188 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4451), {226, 149, 163, 0}}, +#line 962 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4452), {226, 159, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1152 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4456), {226, 169, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1633 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4462), {226, 128, 154, 0}}, + {-1,{0}}, +#line 1656 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4464), {226, 164, 165, 0}}, +#line 956 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4465), {226, 170, 137, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1809 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4468), {226, 139, 145, 0}}, + {-1,{0}}, +#line 161 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4470), {226, 149, 164, 0}}, +#line 1986 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4471), {207, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 253 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4475), {226, 137, 151, 0}}, + {-1,{0}}, +#line 2101 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4477), {240, 157, 149, 170}}, + {-1,{0}}, +#line 1940 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4479), {226, 138, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 825 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4484), {226, 159, 170, 0}}, +#line 1100 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4485), {226, 164, 164, 0}}, +#line 1673 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4486), {209, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 244 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4492), {240, 157, 148, 160}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 799 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4506), {206, 154, 0}}, +#line 943 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4507), {209, 153, 0}}, +#line 1045 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4508), {226, 129, 159, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1810 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4511), {226, 138, 135, 0}}, +#line 1811 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4512), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1544 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4517), {194, 174, 0}}, +#line 30 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4518), {196, 129, 0}}, +#line 908 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4519), {226, 139, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2049 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4524), {226, 132, 152, 0}}, +#line 1892 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4525), {208, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1812 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4529), {226, 138, 139, 0}}, +#line 1140 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4530), {209, 154, 0}}, +#line 2064 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4531), {240, 157, 148, 181}}, + {-1,{0}}, +#line 1071 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4533), {206, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1297 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4539), {226, 167, 158, 0}}, +#line 178 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4540), {226, 149, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2076 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4545), {226, 168, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 886 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4551), {226, 135, 135, 0}}, +#line 1786 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4552), {226, 136, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 111 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4559), {226, 132, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 285 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4563), {226, 136, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1286 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4573), {35, 0}}, +#line 32 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4574), {38, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 173 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4583), {226, 149, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1176 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4590), {226, 137, 175, 0}}, +#line 169 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4591), {226, 138, 158, 0}}, +#line 790 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4592), {200, 183, 0}}, + {-1,{0}}, +#line 1668 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4594), {226, 140, 162, 0}}, + {-1,{0}}, +#line 447 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4596), {196, 144, 0}}, + {-1,{0}}, +#line 36 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4598), {226, 136, 167, 0}}, +#line 1179 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4599), {226, 137, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1181 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4606), {226, 169, 190, 0}}, + {-1,{0}}, +#line 1180 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4608), {226, 137, 185, 0}}, +#line 1483 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4609), {34, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1178 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4616), {226, 137, 167, 0}}, +#line 708 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4617), {226, 128, 144, 0}}, +#line 1411 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4618), {226, 132, 143, 0}}, + {-1,{0}}, +#line 1856 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4620), {226, 137, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1871 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4627), {226, 164, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1008 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4632), {197, 129, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1680 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4635), {194, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2072 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4639), {226, 139, 187, 0}}, +#line 761 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4640), {196, 174, 0}}, + {-1,{0}}, {-1,{0}}, +#line 455 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4643), {208, 143, 0}}, + {-1,{0}}, +#line 1333 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4645), {226, 166, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 270 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4652), {226, 167, 130, 0}}, + {-1,{0}}, +#line 1665 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4654), {226, 156, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1386 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4668), {194, 182, 0}}, + {-1,{0}}, {-1,{0}}, +#line 76 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4671), {42, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1482 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4678), {226, 137, 159, 0}}, + {-1,{0}}, +#line 1787 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4680), {226, 136, 145, 0}}, + {-1,{0}}, +#line 444 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4682), {208, 133, 0}}, + {-1,{0}}, +#line 498 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4684), {197, 138, 0}}, + {-1,{0}}, +#line 2122 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4686), {208, 150, 0}}, + {-1,{0}}, {-1,{0}}, +#line 965 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4689), {226, 159, 181, 0}}, + {-1,{0}}, +#line 346 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4691), {226, 128, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 437 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4699), {226, 134, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1813 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4706), {226, 171, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1457 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4714), {226, 140, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1311 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4718), {195, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 192 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4729), {226, 149, 160, 0}}, + {-1,{0}}, {-1,{0}}, +#line 458 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4732), {195, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1807 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4738), {226, 171, 128, 0}}, + {-1,{0}}, +#line 694 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4740), {226, 134, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 273 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4743), {226, 128, 153, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1887 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4746), {226, 167, 141, 0}}, +#line 405 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4747), {226, 138, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1623 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4751), {226, 139, 138, 0}}, + {-1,{0}}, +#line 1017 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4753), {226, 139, 137, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1864 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4756), {226, 164, 168, 0}}, +#line 23 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4757), {195, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 75 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4760), {226, 137, 148, 0}}, +#line 1492 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4761), {226, 159, 171, 0}}, +#line 760 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4762), {209, 145, 0}}, + {-1,{0}}, +#line 1207 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4764), {226, 170, 175, 0}}, + {-1,{0}}, +#line 61 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4766), {240, 157, 149, 146}}, + {-1,{0}}, +#line 251 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4768), {207, 135, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1479 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4771), {226, 132, 141, 0}}, +#line 187 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4772), {226, 149, 162, 0}}, +#line 1177 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4773), {226, 137, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2066 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4777), {226, 159, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1361 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4791), {226, 132, 180, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1620 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4794), {226, 128, 153, 0}}, + {-1,{0}}, +#line 1006 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4796), {226, 128, 152, 0}}, +#line 2103 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4797), {240, 157, 147, 142}}, + {-1,{0}}, {-1,{0}}, +#line 603 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4800), {196, 161, 0}}, + {-1,{0}}, +#line 1214 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4802), {226, 139, 162, 0}}, +#line 809 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4803), {208, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 202 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4809), {226, 167, 133, 0}}, +#line 1213 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4810), {226, 138, 143, 0}}, +#line 1672 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4811), {208, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2098 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4821), {208, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 338 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4825), {226, 136, 177, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1841 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4828), {206, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1842 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4837), {206, 184, 0}}, +#line 2070 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4838), {226, 159, 184, 0}}, + {-1,{0}}, +#line 1216 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4840), {226, 139, 163, 0}}, + {-1,{0}}, {-1,{0}}, +#line 365 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4843), {226, 166, 177, 0}}, +#line 1875 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4844), {226, 150, 181, 0}}, + {-1,{0}}, +#line 602 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4846), {196, 160, 0}}, + {-1,{0}}, +#line 1215 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4848), {226, 138, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 8 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4857), {196, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 448 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4860), {196, 145, 0}}, +#line 1399 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4861), {226, 128, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1521 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4866), {93, 0}}, + {-1,{0}}, +#line 851 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4868), {91, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1323 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4872), {226, 166, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1347 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4878), {226, 166, 182, 0}}, + {-1,{0}}, +#line 2079 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4880), {226, 159, 185, 0}}, + {-1,{0}}, +#line 1877 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4882), {226, 151, 131, 0}}, +#line 1182 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4883), {226, 137, 181, 0}}, +#line 279 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4884), {226, 137, 148, 0}}, + {-1,{0}}, +#line 967 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4886), {226, 159, 184, 0}}, + {-1,{0}}, +#line 766 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4888), {206, 185, 0}}, + {-1,{0}}, +#line 276 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4890), {58, 0}}, +#line 2118 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4891), {206, 150, 0}}, +#line 596 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4892), {196, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 246 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4897), {208, 167, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2104 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4900), {208, 174, 0}}, +#line 1545 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4901), {194, 174, 0}}, +#line 1822 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4902), {195, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 456 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4909), {209, 159, 0}}, + {-1,{0}}, +#line 110 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4911), {206, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 538 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4918), {226, 130, 172, 0}}, + {-1,{0}}, {-1,{0}}, +#line 874 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4921), {226, 134, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 221 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4924), {226, 133, 133, 0}}, + {-1,{0}}, +#line 1592 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4926), {203, 154, 0}}, +#line 829 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4927), {226, 132, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 391 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4932), {209, 146, 0}}, + {-1,{0}}, +#line 1355 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4934), {226, 138, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 751 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4937), {226, 132, 164, 0}}, +#line 595 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4938), {196, 158, 0}}, + {-1,{0}}, +#line 1908 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4940), {209, 158, 0}}, +#line 537 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4941), {195, 171, 0}}, + {-1,{0}}, {-1,{0}}, +#line 361 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4944), {194, 176, 0}}, + {-1,{0}}, +#line 1982 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4946), {195, 188, 0}}, + {-1,{0}}, {-1,{0}}, +#line 709 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4949), {195, 141, 0}}, +#line 1780 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4950), {226, 170, 176, 0}}, + {-1,{0}}, +#line 811 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4952), {208, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 319 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4961), {226, 137, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1893 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4975), {209, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 241 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4982), {194, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 390 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str4991), {208, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1857 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5009), {226, 137, 133, 0}}, + {-1,{0}}, +#line 1879 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5011), {226, 137, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 453 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5016), {226, 165, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 879 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5025), {226, 159, 166, 0}}, + {-1,{0}}, +#line 942 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5027), {208, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 718 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5036), {208, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1878 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5043), {226, 138, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1110 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5049), {226, 137, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1254 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5055), {226, 136, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1099 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5062), {226, 128, 147, 0}}, +#line 148 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5063), {226, 139, 136, 0}}, + {-1,{0}}, +#line 557 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5065), {102, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1907 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5072), {208, 142, 0}}, + {-1,{0}}, +#line 1999 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5074), {207, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1981 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5078), {195, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2001 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5084), {226, 138, 179, 0}}, +#line 2000 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5085), {226, 138, 178, 0}}, +#line 74 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5086), {240, 157, 146, 182}}, + {-1,{0}}, {-1,{0}}, +#line 1775 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5089), {226, 137, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 337 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5093), {226, 136, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1638 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5101), {226, 137, 187, 0}}, + {-1,{0}}, +#line 559 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5103), {239, 172, 130, 0}}, + {-1,{0}}, +#line 256 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5105), {226, 138, 155, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2009 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5108), {226, 138, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1292 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5112), {226, 138, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1803 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5120), {226, 165, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1602 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5124), {226, 159, 167, 0}}, + {-1,{0}}, +#line 964 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5126), {226, 159, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2007 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5142), {226, 138, 162, 0}}, +#line 2107 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5143), {197, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 654 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5151), {62, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 226 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5156), {226, 169, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1776 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5173), {226, 137, 187, 0}}, +#line 1310 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5174), {195, 147, 0}}, +#line 1874 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5175), {226, 132, 162, 0}}, +#line 1139 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5176), {208, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 657 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5181), {226, 139, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2097 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5189), {240, 157, 148, 182}}, + {-1,{0}}, {-1,{0}}, +#line 284 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5192), {226, 136, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 656 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5197), {226, 137, 171, 0}}, +#line 1647 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5198), {226, 170, 182, 0}}, +#line 731 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5199), {196, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 261 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5203), {226, 147, 136, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2095 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5206), {194, 165, 0}}, + {-1,{0}}, +#line 1843 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5208), {207, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 783 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5211), {195, 175, 0}}, +#line 1778 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5212), {226, 137, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 159 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5217), {226, 149, 144, 0}}, +#line 1073 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5218), {226, 138, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1577 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5222), {226, 135, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 280 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5227), {226, 137, 148, 0}}, + {-1,{0}}, +#line 1637 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5229), {226, 170, 188, 0}}, +#line 629 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5230), {226, 170, 164, 0}}, +#line 719 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5231), {194, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 234 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5234), {226, 169, 140, 0}}, + {-1,{0}}, +#line 2059 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5236), {226, 139, 130, 0}}, +#line 2123 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5237), {208, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 163 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5241), {226, 149, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 911 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5250), {226, 169, 189, 0}}, + {-1,{0}}, +#line 1957 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5252), {226, 134, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 350 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5257), {203, 157, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1470 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5260), {226, 128, 136, 0}}, + {-1,{0}}, +#line 228 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5262), {196, 141, 0}}, + {-1,{0}}, +#line 1519 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5264), {226, 157, 179, 0}}, + {-1,{0}}, +#line 849 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5266), {226, 157, 178, 0}}, + {-1,{0}}, +#line 58 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5268), {196, 132, 0}}, +#line 898 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5269), {226, 167, 143, 0}}, + {-1,{0}}, {-1,{0}}, +#line 615 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5272), {226, 170, 132, 0}}, +#line 900 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5273), {226, 138, 180, 0}}, +#line 899 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5274), {226, 138, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 290 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5280), {226, 136, 174, 0}}, + {-1,{0}}, {-1,{0}}, +#line 439 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5283), {226, 164, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1626 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5295), {226, 150, 184, 0}}, + {-1,{0}}, +#line 1022 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5297), {226, 151, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1548 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5300), {226, 165, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 878 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5306), {226, 140, 136, 0}}, + {-1,{0}}, +#line 1979 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5308), {226, 150, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2061 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5314), {226, 139, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 545 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5319), {226, 137, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1528 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5325), {197, 151, 0}}, + {-1,{0}}, +#line 858 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5327), {196, 188, 0}}, + {-1,{0}}, +#line 1643 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5329), {197, 159, 0}}, + {-1,{0}}, +#line 1830 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5331), {197, 162, 0}}, + {-1,{0}}, +#line 1748 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5333), {226, 152, 133, 0}}, +#line 168 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5334), {226, 138, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1831 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5340), {197, 163, 0}}, +#line 2117 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5341), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1093 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5350), {197, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1404 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5358), {207, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 711 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5375), {226, 129, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 220 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5384), {226, 169, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 445 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5387), {209, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 248 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5397), {226, 156, 147, 0}}, +#line 1381 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5398), {226, 140, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1280 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5405), {226, 139, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1580 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5411), {226, 138, 162, 0}}, +#line 1294 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5412), {226, 137, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 892 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5424), {226, 134, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 987 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5431), {226, 151, 138, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1583 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5434), {226, 167, 144, 0}}, + {-1,{0}}, +#line 1581 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5436), {226, 165, 155, 0}}, + {-1,{0}}, +#line 1585 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5438), {226, 138, 181, 0}}, +#line 1584 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5439), {226, 138, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 802 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5449), {196, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1642 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5457), {197, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 268 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5468), {226, 168, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 490 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5471), {226, 136, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 22 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5478), {240, 157, 148, 158}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 376 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5482), {203, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 882 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5489), {226, 135, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 881 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5492), {226, 165, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 907 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5501), {226, 170, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 68 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5509), {226, 129, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 208 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5512), {226, 170, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 857 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5524), {196, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 223 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5528), {226, 129, 129, 0}}, + {-1,{0}}, +#line 91 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5530), {226, 171, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 229 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5543), {195, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 260 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5547), {194, 174, 0}}, +#line 880 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5548), {226, 165, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1895 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5552), {209, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 402 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5556), {226, 137, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 242 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5564), {194, 183, 0}}, + {-1,{0}}, +#line 1281 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5566), {226, 139, 172, 0}}, + {-1,{0}}, +#line 1056 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5568), {226, 136, 146, 0}}, + {-1,{0}}, +#line 623 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5570), {226, 132, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 6 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5577), {195, 129, 0}}, +#line 653 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5578), {226, 169, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 661 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5583), {226, 165, 184, 0}}, +#line 205 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5584), {226, 128, 162, 0}}, + {-1,{0}}, {-1,{0}}, +#line 423 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5587), {226, 134, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1536 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5593), {226, 128, 157, 0}}, + {-1,{0}}, +#line 865 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5595), {226, 128, 158, 0}}, + {-1,{0}}, {-1,{0}}, +#line 755 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5598), {226, 168, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1977 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5602), {197, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 589 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5612), {199, 181, 0}}, + {-1,{0}}, +#line 1278 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5614), {195, 177, 0}}, +#line 20 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5615), {226, 129, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 703 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5618), {196, 166, 0}}, + {-1,{0}}, +#line 543 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5620), {226, 133, 135, 0}}, +#line 1055 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5621), {226, 138, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1587 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5625), {226, 165, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1964 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5630), {226, 134, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2119 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5639), {206, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 373 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5644), {203, 153, 0}}, +#line 374 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5645), {203, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1146 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5663), {226, 134, 154, 0}}, +#line 691 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5664), {226, 164, 166, 0}}, + {-1,{0}}, +#line 729 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5666), {226, 132, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 62 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5669), {226, 169, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1092 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5673), {197, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 214 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5678), {226, 169, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1042 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5686), {226, 128, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 554 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5689), {239, 172, 129, 0}}, +#line 1648 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5690), {226, 139, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1540 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5699), {226, 132, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 897 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5703), {226, 139, 139, 0}}, +#line 77 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5704), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 685 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5718), {226, 128, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 451 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5722), {226, 150, 190, 0}}, + {-1,{0}}, +#line 1175 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5724), {226, 136, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1639 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5728), {226, 137, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2089 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5733), {208, 175, 0}}, +#line 1976 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5734), {197, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1173 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5741), {226, 137, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1848 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5747), {226, 128, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 64 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5754), {226, 169, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 206 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5762), {226, 128, 162, 0}}, + {-1,{0}}, {-1,{0}}, +#line 272 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5765), {226, 128, 157, 0}}, +#line 363 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5766), {206, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 620 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5776), {226, 137, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1378 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5780), {226, 138, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2056 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5799), {226, 137, 128, 0}}, + {-1,{0}}, +#line 1527 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5801), {197, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 535 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5807), {195, 176, 0}}, +#line 1805 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5808), {226, 171, 140, 0}}, + {-1,{0}}, {-1,{0}}, +#line 84 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5811), {226, 168, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 195 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5817), {203, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 621 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5822), {226, 139, 153, 0}}, + {-1,{0}}, +#line 706 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5824), {226, 137, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 948 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5837), {226, 135, 154, 0}}, +#line 154 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5838), {226, 148, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1782 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5847), {226, 170, 182, 0}}, +#line 1971 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5848), {197, 175, 0}}, +#line 929 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5849), {226, 169, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1290 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5860), {226, 138, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 669 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5866), {203, 135, 0}}, +#line 779 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5867), {196, 169, 0}}, + {-1,{0}}, {-1,{0}}, +#line 765 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5870), {206, 153, 0}}, + {-1,{0}}, +#line 759 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5872), {208, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 156 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5884), {226, 149, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1779 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5891), {226, 137, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 883 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5905), {226, 140, 138, 0}}, +#line 2041 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5906), {226, 138, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1876 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5923), {226, 150, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 969 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5927), {226, 159, 183, 0}}, +#line 1572 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5928), {226, 140, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 434 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5931), {226, 165, 159, 0}}, + {-1,{0}}, +#line 1480 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5933), {226, 168, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1277 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5937), {195, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 210 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5940), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 668 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5949), {226, 137, 169, 0}}, + {-1,{0}}, +#line 164 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5951), {226, 148, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 658 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5956), {226, 166, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1237 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5959), {226, 138, 128, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1380 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5962), {195, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 611 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5970), {226, 170, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 536 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5976), {195, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1970 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5980), {197, 174, 0}}, + {-1,{0}}, +#line 1937 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5982), {226, 142, 181, 0}}, +#line 1161 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5983), {226, 137, 170, 0}}, +#line 872 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5984), {226, 135, 164, 0}}, +#line 1095 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str5985), {226, 169, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 78 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6003), {226, 137, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1058 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6023), {226, 168, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 364 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6030), {206, 180, 0}}, + {-1,{0}}, +#line 678 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6032), {226, 134, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 38 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6038), {226, 169, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 237 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6043), {196, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 225 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6048), {226, 132, 173, 0}}, +#line 166 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6049), {226, 149, 168, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1784 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6052), {226, 137, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 266 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6061), {226, 167, 131, 0}}, +#line 1653 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6062), {226, 138, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1318 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6066), {226, 138, 157, 0}}, +#line 269 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6067), {226, 171, 175, 0}}, +#line 1802 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6068), {226, 171, 151, 0}}, +#line 1795 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6069), {226, 171, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1794 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6077), {226, 170, 190, 0}}, + {-1,{0}}, +#line 83 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6079), {226, 136, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1894 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6084), {208, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 639 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6087), {96, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1004 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6101), {226, 170, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1949 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6106), {226, 135, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 906 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6121), {226, 134, 188, 0}}, +#line 416 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6122), {226, 135, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1108 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6129), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 941 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6140), {226, 150, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 267 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6146), {226, 137, 151, 0}}, +#line 1293 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6147), {226, 138, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1927 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6151), {226, 150, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 737 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6155), {226, 132, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1586 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6161), {226, 165, 143, 0}}, + {-1,{0}}, {-1,{0}}, +#line 151 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6164), {226, 149, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 626 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6176), {226, 170, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 782 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6193), {195, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1325 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6203), {197, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1198 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6208), {226, 169, 189, 0}}, + {-1,{0}}, +#line 153 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6210), {226, 149, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 591 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6215), {206, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1377 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6236), {226, 168, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 968 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6248), {226, 159, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 590 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6261), {206, 147, 0}}, +#line 127 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6262), {226, 139, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 160 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6268), {226, 148, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1796 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6283), {226, 171, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 902 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6292), {226, 165, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 614 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6298), {226, 170, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 800 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6304), {206, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1124 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6315), {226, 169, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 665 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6340), {226, 137, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 550 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6351), {239, 172, 128, 0}}, +#line 121 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6352), {226, 168, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 808 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6367), {196, 184, 0}}, +#line 1797 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6368), {226, 138, 135, 0}}, + {-1,{0}}, +#line 170 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6370), {226, 138, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 631 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6386), {226, 170, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 427 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6394), {226, 135, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 125 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6403), {226, 168, 132, 0}}, +#line 810 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6404), {209, 133, 0}}, + {-1,{0}}, +#line 355 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6406), {226, 128, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1379 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6418), {195, 150, 0}}, + {-1,{0}}, +#line 109 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6420), {206, 146, 0}}, +#line 1057 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6421), {226, 136, 184, 0}}, +#line 1783 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6422), {226, 139, 169, 0}}, + {-1,{0}}, +#line 310 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6424), {226, 139, 175, 0}}, + {-1,{0}}, {-1,{0}}, +#line 812 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6427), {209, 156, 0}}, +#line 625 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6428), {209, 147, 0}}, + {-1,{0}}, +#line 1094 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6430), {226, 137, 135, 0}}, +#line 2085 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6431), {226, 139, 129, 0}}, +#line 98 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6432), {226, 137, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1722 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6439), {226, 138, 145, 0}}, + {-1,{0}}, {-1,{0}}, +#line 155 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6442), {226, 149, 146, 0}}, + {-1,{0}}, {-1,{0}}, +#line 970 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6445), {226, 159, 186, 0}}, + {-1,{0}}, +#line 1721 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6447), {226, 138, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 430 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6451), {226, 165, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1723 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6454), {226, 138, 143, 0}}, + {-1,{0}}, +#line 1229 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6456), {226, 136, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1174 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6461), {226, 137, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 150 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6485), {226, 148, 144, 0}}, + {-1,{0}}, {-1,{0}}, +#line 157 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6488), {226, 149, 148, 0}}, + {-1,{0}}, +#line 34 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6490), {226, 169, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1591 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6502), {226, 135, 128, 0}}, + {-1,{0}}, +#line 730 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6504), {196, 178, 0}}, +#line 1226 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6505), {226, 137, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 57 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6509), {226, 141, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 52 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6515), {226, 136, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 11 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6521), {226, 136, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 37 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6524), {226, 169, 156, 0}}, + {-1,{0}}, +#line 1240 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6526), {226, 164, 179, 0}}, +#line 2025 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6527), {226, 128, 138, 0}}, + {-1,{0}}, +#line 1799 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6529), {226, 138, 131, 0}}, + {-1,{0}}, +#line 152 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6531), {226, 149, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2029 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6535), {226, 138, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 235 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6538), {226, 169, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1987 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6548), {226, 136, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1532 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6552), {209, 128, 0}}, + {-1,{0}}, +#line 862 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6554), {208, 187, 0}}, + {-1,{0}}, +#line 1652 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6556), {209, 129, 0}}, + {-1,{0}}, +#line 1832 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6558), {208, 162, 0}}, +#line 2112 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6559), {208, 151, 0}}, +#line 468 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6560), {209, 141, 0}}, +#line 1537 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6561), {226, 134, 179, 0}}, + {-1,{0}}, +#line 868 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6563), {226, 134, 178, 0}}, + {-1,{0}}, +#line 1914 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6565), {209, 131, 0}}, +#line 184 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6566), {226, 149, 172, 0}}, +#line 1833 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6567), {209, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1098 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6577), {208, 189, 0}}, + {-1,{0}}, +#line 100 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6579), {208, 177, 0}}, +#line 1276 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6580), {226, 137, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 786 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6585), {208, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 288 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6600), {226, 169, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 56 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6607), {195, 133, 0}}, + {-1,{0}}, +#line 1569 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6609), {226, 165, 157, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1385 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6612), {226, 143, 156, 0}}, +#line 1019 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6613), {226, 169, 187, 0}}, + {-1,{0}}, +#line 1394 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6615), {208, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1375 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6618), {195, 181, 0}}, +#line 1535 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6619), {226, 128, 157, 0}}, + {-1,{0}}, +#line 864 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6621), {226, 128, 156, 0}}, + {-1,{0}}, +#line 2005 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6623), {208, 146, 0}}, + {-1,{0}}, {-1,{0}}, +#line 215 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6626), {226, 169, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 101 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6646), {226, 128, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 421 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6650), {226, 164, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2006 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6657), {208, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 53 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6665), {226, 138, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 804 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6676), {208, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1040 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6683), {208, 156, 0}}, +#line 1651 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6684), {208, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1115 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6691), {10, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 547 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6696), {209, 132, 0}}, +#line 1913 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6697), {208, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 183 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6704), {226, 149, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 353 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6715), {208, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 704 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6738), {196, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 861 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6751), {208, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2093 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6762), {208, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1814 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6775), {226, 171, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1164 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6789), {194, 160, 0}}, +#line 1382 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6790), {226, 128, 190, 0}}, +#line 1724 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6791), {226, 138, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 624 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6797), {208, 131, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1383 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6800), {226, 143, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 512 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6806), {226, 137, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1384 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6819), {226, 142, 180, 0}}, + {-1,{0}}, +#line 81 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6821), {195, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 15 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6829), {194, 180, 0}}, +#line 715 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6830), {208, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 778 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6849), {196, 168, 0}}, +#line 689 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6850), {226, 132, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1344 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6854), {207, 137, 0}}, +#line 213 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6855), {196, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1645 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6861), {197, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 464 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6865), {195, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1912 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6870), {195, 187, 0}}, + {-1,{0}}, +#line 645 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6872), {226, 169, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 784 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6890), {196, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1291 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6895), {226, 138, 173, 0}}, +#line 2043 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6896), {197, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1097 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6900), {208, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1579 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6921), {226, 134, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 924 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6942), {226, 137, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1010 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6958), {226, 170, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 26 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6963), {226, 132, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 354 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6979), {208, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1644 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6989), {197, 156, 0}}, + {-1,{0}}, +#line 919 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str6991), {226, 170, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 717 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7000), {208, 149, 0}}, +#line 985 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7001), {226, 134, 152, 0}}, +#line 1911 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7002), {195, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 24 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7021), {195, 160, 0}}, + {-1,{0}}, +#line 1059 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7023), {226, 136, 147, 0}}, +#line 126 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7024), {226, 139, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1531 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7028), {208, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1801 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7034), {226, 159, 137, 0}}, + {-1,{0}}, {-1,{0}}, +#line 494 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7037), {226, 150, 171, 0}}, + {-1,{0}}, +#line 162 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7039), {226, 149, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1435 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7047), {226, 170, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 54 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7066), {226, 166, 157, 0}}, +#line 2091 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7067), {197, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1752 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7071), {226, 138, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1374 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7074), {195, 149, 0}}, +#line 231 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7075), {196, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 546 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7085), {208, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 286 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7090), {226, 132, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1762 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7096), {226, 165, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 757 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7115), {226, 129, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 175 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7120), {226, 148, 148, 0}}, +#line 9 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7121), {196, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1279 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7127), {226, 137, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 713 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7135), {195, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2062 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7142), {226, 150, 189, 0}}, +#line 252 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7143), {203, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 662 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7168), {226, 139, 151, 0}}, + {-1,{0}}, {-1,{0}}, +#line 610 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7171), {226, 169, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1282 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7183), {226, 139, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 313 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7198), {226, 139, 158, 0}}, +#line 1753 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7199), {226, 139, 144, 0}}, + {-1,{0}}, +#line 1041 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7201), {208, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1859 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7212), {226, 168, 177, 0}}, + {-1,{0}}, +#line 690 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7214), {226, 164, 165, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1682 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7217), {207, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 324 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7224), {226, 169, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1372 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7230), {195, 184, 0}}, +#line 457 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7231), {226, 159, 191, 0}}, + {-1,{0}}, {-1,{0}}, +#line 891 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7234), {226, 135, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1576 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7245), {226, 135, 140, 0}}, + {-1,{0}}, +#line 803 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7247), {196, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1758 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7256), {226, 171, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 332 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7260), {194, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 896 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7269), {226, 165, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 122 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7274), {226, 152, 133, 0}}, + {-1,{0}}, {-1,{0}}, +#line 320 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7277), {226, 136, 170, 0}}, +#line 973 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7278), {226, 159, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 597 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7294), {196, 162, 0}}, + {-1,{0}}, +#line 1439 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7296), {226, 170, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2113 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7307), {208, 183, 0}}, + {-1,{0}}, +#line 1412 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7309), {226, 132, 142, 0}}, +#line 1343 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7310), {206, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1771 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7317), {226, 171, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1533 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7325), {226, 164, 183, 0}}, +#line 325 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7326), {226, 136, 170, 0}}, +#line 863 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7327), {226, 164, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1763 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7332), {226, 138, 130, 0}}, +#line 1219 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7333), {226, 138, 129, 0}}, +#line 876 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7334), {226, 135, 134, 0}}, + {-1,{0}}, {-1,{0}}, +#line 2044 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7337), {197, 181, 0}}, +#line 1560 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7338), {226, 159, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1283 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7344), {226, 139, 173, 0}}, +#line 1681 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7345), {206, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1222 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7350), {226, 137, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 372 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7364), {194, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1760 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7376), {226, 138, 138, 0}}, + {-1,{0}}, +#line 1456 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7378), {226, 136, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 258 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7385), {226, 138, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1772 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7389), {226, 171, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 297 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7397), {194, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 533 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7403), {206, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 51 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7409), {226, 136, 161, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1083 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7434), {226, 153, 174, 0}}, + {-1,{0}}, +#line 1798 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7436), {226, 171, 132, 0}}, +#line 1084 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7437), {226, 132, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1880 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7443), {226, 150, 185, 0}}, + {-1,{0}}, +#line 375 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7445), {96, 0}}, +#line 172 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7446), {226, 149, 155, 0}}, +#line 287 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7447), {226, 137, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1835 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7451), {226, 140, 149, 0}}, + {-1,{0}}, {-1,{0}}, +#line 281 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7454), {44, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1764 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7460), {226, 139, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1221 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7475), {226, 139, 161, 0}}, +#line 663 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7476), {226, 139, 155, 0}}, +#line 79 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7477), {195, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 326 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7484), {226, 134, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 312 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7491), {226, 164, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 311 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7495), {226, 164, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1765 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7503), {226, 138, 134, 0}}, +#line 1766 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7504), {226, 171, 133, 0}}, +#line 1578 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7505), {226, 134, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 318 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7520), {226, 169, 134, 0}}, +#line 1768 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7521), {226, 138, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 59 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7532), {196, 133, 0}}, +#line 1190 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7533), {226, 139, 182, 0}}, +#line 1582 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7534), {226, 139, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2088 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7552), {195, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1147 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7563), {226, 135, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1317 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7581), {208, 190, 0}}, +#line 240 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7582), {226, 166, 178, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 467 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7595), {208, 173, 0}}, + {-1,{0}}, {-1,{0}}, +#line 322 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7598), {226, 169, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1881 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7604), {226, 138, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 888 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7615), {226, 134, 148, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1774 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7618), {226, 137, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 425 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7631), {226, 135, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1324 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7641), {197, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 247 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7648), {209, 135, 0}}, +#line 664 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7649), {226, 170, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 42 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7655), {226, 136, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 12 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7662), {226, 136, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1597 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7668), {226, 142, 177, 0}}, + {-1,{0}}, +#line 953 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7670), {226, 142, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1109 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7674), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1082 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7677), {226, 137, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1371 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7686), {195, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1769 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7698), {226, 171, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 71 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7723), {195, 133, 0}}, +#line 176 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7724), {226, 149, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1761 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7730), {226, 170, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 2086 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7742), {226, 139, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 171 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7767), {226, 148, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 189 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7778), {226, 148, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 705 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7800), {226, 137, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 714 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7812), {208, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 70 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7828), {226, 137, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 7 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7841), {195, 161, 0}}, +#line 66 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7842), {226, 137, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1951 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7859), {226, 134, 149, 0}}, + {-1,{0}}, +#line 1113 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7861), {226, 137, 171, 0}}, + {-1,{0}}, +#line 787 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7863), {208, 185, 0}}, + {-1,{0}}, {-1,{0}}, +#line 666 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7866), {226, 137, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 179 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7876), {226, 148, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1314 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7886), {195, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 463 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7900), {195, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1205 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str7987), {226, 139, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 124 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8006), {226, 150, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 342 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8032), {226, 132, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1316 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8037), {208, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 681 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8042), {196, 164, 0}}, +#line 1590 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8043), {226, 165, 147, 0}}, +#line 18 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8044), {195, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 556 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8063), {226, 150, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 622 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8084), {226, 139, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 99 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8088), {208, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1426 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8099), {226, 132, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 186 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8104), {226, 149, 161, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1392 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8107), {226, 136, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 712 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8117), {195, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 315 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8129), {226, 134, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 158 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8135), {226, 148, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 39 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8142), {226, 169, 154, 0}}, + {-1,{0}}, +#line 1788 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8144), {226, 153, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1568 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8148), {226, 159, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 785 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8168), {196, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1935 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8174), {95, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1563 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8241), {226, 134, 146, 0}}, +#line 257 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8242), {226, 138, 154, 0}}, +#line 27 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8243), {206, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 885 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8251), {226, 134, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 316 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8258), {226, 164, 189, 0}}, + {-1,{0}}, +#line 1565 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8260), {226, 135, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1994 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8281), {207, 130, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1287 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8300), {226, 132, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 551 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8310), {239, 172, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 984 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8326), {226, 134, 153, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 542 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8340), {226, 132, 176, 0}}, + {-1,{0}}, +#line 1313 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8342), {195, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2090 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8351), {209, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 823 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8375), {206, 187, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1220 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8381), {226, 170, 176, 0}}, +#line 190 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8382), {226, 149, 158, 0}}, + {-1,{0}}, +#line 123 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8384), {226, 150, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 40 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8391), {226, 136, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2083 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8404), {226, 168, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1074 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8424), {226, 136, 135, 0}}, +#line 185 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8425), {226, 148, 164, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 532 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8438), {206, 151, 0}}, + {-1,{0}}, +#line 16 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8440), {208, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 805 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8474), {208, 186, 0}}, +#line 601 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8475), {208, 179, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 893 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8485), {226, 165, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 230 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8491), {195, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 90 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8495), {226, 136, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 702 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8506), {226, 132, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1393 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8515), {208, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 600 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8521), {208, 147, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 659 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8534), {226, 169, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 822 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8572), {206, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1321 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8627), {226, 168, 184, 0}}, + {-1,{0}}, +#line 884 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8629), {226, 134, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 971 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8672), {226, 159, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 797 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8677), {208, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 866 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8687), {226, 165, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2084 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8700), {226, 150, 179, 0}}, +#line 1245 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8701), {226, 135, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 544 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8725), {226, 133, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1244 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8735), {226, 134, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 13 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8745), {195, 130, 0}}, +#line 1163 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8746), {226, 129, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 599 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8780), {196, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 41 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8784), {226, 166, 164, 0}}, +#line 327 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8785), {226, 164, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1670 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8791), {208, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2106 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8796), {195, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1759 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8800), {226, 171, 139, 0}}, + {-1,{0}}, {-1,{0}}, +#line 359 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8803), {226, 164, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1628 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8810), {226, 167, 180, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 598 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8826), {196, 156, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 795 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8843), {208, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 652 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8879), {226, 170, 167, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 781 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8922), {209, 150, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1950 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8956), {226, 134, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 330 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8962), {226, 139, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 549 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8972), {239, 172, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2099 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str8992), {209, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 389 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9015), {226, 139, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 660 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9026), {226, 170, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1754 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9069), {226, 170, 189, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 890 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9079), {226, 135, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 82 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9085), {195, 164, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1952 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9088), {226, 135, 149, 0}}, + {-1,{0}}, +#line 1575 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9090), {226, 135, 132, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 436 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9151), {226, 135, 129, 0}}, + {-1,{0}}, {-1,{0}}, +#line 435 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9154), {226, 165, 151, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 682 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9162), {196, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1613 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9186), {226, 135, 155, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 972 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9217), {226, 159, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 323 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9239), {226, 138, 141, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 10 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9249), {226, 136, 190, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 695 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9268), {226, 134, 170, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1107 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9271), {226, 128, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1755 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9275), {226, 171, 133, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1900 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9307), {226, 134, 160, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 429 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9320), {226, 135, 130, 0}}, +#line 428 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9321), {226, 135, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 19 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9326), {195, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1534 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9330), {226, 165, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 331 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9349), {226, 139, 143, 0}}, + {-1,{0}}, +#line 707 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9351), {226, 129, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1756 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9360), {226, 138, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 974 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9414), {226, 159, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 239 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9484), {194, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1188 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9505), {226, 136, 137, 0}}, +#line 1777 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9506), {226, 170, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 887 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9554), {226, 134, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1749 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9580), {207, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 31 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9627), {226, 168, 191, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 80 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9741), {195, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1567 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9747), {226, 140, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 889 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9751), {226, 135, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1770 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9767), {226, 171, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2022 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9788), {124, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1589 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9801), {226, 134, 190, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1588 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9804), {226, 165, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1571 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9829), {226, 135, 130, 0}}, + {-1,{0}}, {-1,{0}}, +#line 1570 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9832), {226, 165, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 25 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9836), {226, 132, 181, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 255 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9852), {226, 134, 187, 0}}, +#line 254 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9853), {226, 134, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 780 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9904), {208, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1376 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9936), {226, 168, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 753 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9944), {226, 138, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1845 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9952), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, +#line 798 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9955), {209, 148, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1203 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9959), {226, 136, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1443 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9963), {226, 170, 185, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 335 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9983), {226, 139, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 72 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str9987), {195, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 232 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10023), {196, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1562 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10029), {226, 134, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 752 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10061), {226, 136, 171, 0}}, +#line 2060 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10062), {226, 151, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 796 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10121), {209, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 249 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10206), {226, 156, 147, 0}}, + {-1,{0}}, +#line 2024 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10208), {226, 137, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 182 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10219), {226, 149, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1210 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10240), {226, 167, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1212 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10244), {226, 139, 173, 0}}, +#line 1211 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10245), {226, 139, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 905 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10278), {226, 165, 146, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 181 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10357), {226, 148, 188, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 149 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10395), {226, 167, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2094 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10415), {209, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1757 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10428), {226, 171, 131, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1706 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10445), {208, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1564 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10505), {226, 135, 146, 0}}, + {-1,{0}}, +#line 28 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10507), {206, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1671 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10528), {209, 137, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1707 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10584), {209, 140, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 17 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10704), {208, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2092 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10720), {197, 183, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 116 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10791), {226, 151, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 735 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10808), {226, 133, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 69 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10847), {226, 137, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1800 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10851), {226, 138, 135, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 2042 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10879), {226, 166, 154, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 314 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10888), {226, 139, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1938 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str10947), {226, 143, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 14 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11009), {195, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1773 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11029), {226, 170, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1039 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11047), {226, 168, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 47 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11146), {226, 166, 172, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 44 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11165), {226, 166, 169, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 48 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11282), {226, 166, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 55 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11366), {226, 136, 162, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1025 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11527), {226, 165, 166, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 46 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11565), {226, 166, 171, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1899 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11664), {226, 134, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 339 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11720), {226, 140, 173, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1750 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11791), {207, 149, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1072 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11840), {226, 138, 184, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1561 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str11918), {226, 135, 165, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 867 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12012), {226, 165, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 871 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12103), {226, 159, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1629 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12170), {226, 165, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 328 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12202), {226, 139, 158, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2105 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12206), {209, 142, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1024 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12288), {226, 165, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 674 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12413), {209, 138, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1573 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12461), {226, 135, 129, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1574 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12497), {226, 135, 128, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 673 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12502), {208, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1767 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12651), {226, 138, 134, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 384 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12809), {207, 157, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1917 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12892), {197, 177, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1785 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12985), {226, 136, 139, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 336 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str12991), {226, 139, 143, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, +#line 1916 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13024), {197, 176, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 49 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13061), {226, 166, 174, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 50 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13443), {226, 166, 175, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2021 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13643), {226, 136, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 2023 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13659), {226, 157, 152, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1566 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13709), {226, 134, 163, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1320 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13908), {197, 145, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, +#line 1781 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str13945), {226, 170, 186, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 45 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str14304), {226, 166, 170, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 1319 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str14364), {197, 144, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 317 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str14620), {226, 169, 136, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 43 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str15290), {226, 166, 168, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 329 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str15360), {226, 139, 159, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 333 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str15729), {226, 134, 182, 0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, + {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, {-1,{0}}, +#line 334 "src/html_unescape.gperf" + {offsetof(struct entity_pool_t, entity_pool_str16000), {226, 134, 183, 0}} + }; + + if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) + { + unsigned int key = hash_entity (str, len); + + if (key <= MAX_HASH_VALUE) + if (len == lengthtable[key]) + { + register const char *s = wordlist[key].entity + entity_pool; + + if (*str == *s && !memcmp (str + 1, s + 1, len - 1)) + return &wordlist[key]; + } + } + return 0; +} diff --git a/cmark/inlines.c b/cmark/inlines.c new file mode 100644 --- /dev/null +++ b/cmark/inlines.c @@ -0,0 +1,1145 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "config.h" +#include "node.h" +#include "parser.h" +#include "references.h" +#include "cmark.h" +#include "houdini.h" +#include "utf8.h" +#include "scanners.h" +#include "inlines.h" + + +static const char *EMDASH = "\xE2\x80\x94"; +static const char *ENDASH = "\xE2\x80\x93"; +static const char *ELLIPSES = "\xE2\x80\xA6"; +static const char *LEFTDOUBLEQUOTE = "\xE2\x80\x9C"; +static const char *RIGHTDOUBLEQUOTE = "\xE2\x80\x9D"; +static const char *LEFTSINGLEQUOTE = "\xE2\x80\x98"; +static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99"; + + +// Macros for creating various kinds of simple. +#define make_str(s) make_literal(CMARK_NODE_TEXT, s) +#define make_code(s) make_literal(CMARK_NODE_CODE, s) +#define make_raw_html(s) make_literal(CMARK_NODE_INLINE_HTML, s) +#define make_linebreak() make_simple(CMARK_NODE_LINEBREAK) +#define make_softbreak() make_simple(CMARK_NODE_SOFTBREAK) +#define make_emph() make_simple(CMARK_NODE_EMPH) +#define make_strong() make_simple(CMARK_NODE_STRONG) + +typedef struct delimiter { + struct delimiter *previous; + struct delimiter *next; + cmark_node *inl_text; + int position; + unsigned char delim_char; + bool can_open; + bool can_close; + bool active; +} delimiter; + +typedef struct { + cmark_chunk input; + int pos; + cmark_reference_map *refmap; + delimiter *last_delim; +} subject; + +static delimiter* +S_insert_emph(subject *subj, delimiter *opener, delimiter *closer); + +static int parse_inline(subject* subj, cmark_node * parent, int options); + +static void subject_from_buf(subject *e, cmark_strbuf *buffer, + cmark_reference_map *refmap); +static int subject_find_special_char(subject *subj, int options); + +static unsigned char *cmark_clean_autolink(cmark_chunk *url, int is_email) +{ + cmark_strbuf buf = GH_BUF_INIT; + + cmark_chunk_trim(url); + + if (url->len == 0) + return NULL; + + if (is_email) + cmark_strbuf_puts(&buf, "mailto:"); + + houdini_unescape_html_f(&buf, url->data, url->len); + return cmark_strbuf_detach(&buf); +} + +static inline cmark_node *make_link(cmark_node *label, unsigned char *url, unsigned char *title) +{ + cmark_node* e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = CMARK_NODE_LINK; + e->first_child = label; + e->last_child = label; + e->as.link.url = url; + e->as.link.title = title; + e->next = NULL; + label->parent = e; + } + return e; +} + +static inline cmark_node* make_autolink(cmark_node* label, cmark_chunk url, int is_email) +{ + return make_link(label, cmark_clean_autolink(&url, is_email), NULL); +} + +// Create an inline with a literal string value. +static inline cmark_node* make_literal(cmark_node_type t, cmark_chunk s) +{ + cmark_node * e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = t; + e->as.literal = s; + e->next = NULL; + e->prev = NULL; + e->parent = NULL; + e->first_child = NULL; + e->last_child = NULL; + // These fields aren't used for inlines: + e->start_line = 0; + e->start_column = 0; + e->end_line = 0; + } + return e; +} + +// Create an inline with no value. +static inline cmark_node* make_simple(cmark_node_type t) +{ + cmark_node* e = (cmark_node *)calloc(1, sizeof(*e)); + if(e != NULL) { + e->type = t; + e->next = NULL; + e->prev = NULL; + e->parent = NULL; + e->first_child = NULL; + e->last_child = NULL; + // These fields aren't used for inlines: + e->start_line = 0; + e->start_column = 0; + e->end_line = 0; + } + return e; +} + +static unsigned char *bufdup(const unsigned char *buf) +{ + unsigned char *new_buf = NULL; + + if (buf) { + int len = strlen((char *)buf); + new_buf = (unsigned char *)calloc(len + 1, sizeof(*new_buf)); + if(new_buf != NULL) { + memcpy(new_buf, buf, len + 1); + } + } + + return new_buf; +} + +static void subject_from_buf(subject *e, cmark_strbuf *buffer, + cmark_reference_map *refmap) +{ + e->input.data = buffer->ptr; + e->input.len = buffer->size; + e->input.alloc = 0; + e->pos = 0; + e->refmap = refmap; + e->last_delim = NULL; + + cmark_chunk_rtrim(&e->input); +} + +static inline int isbacktick(int c) +{ + return (c == '`'); +} + +static inline unsigned char peek_char(subject *subj) +{ + return (subj->pos < subj->input.len) ? subj->input.data[subj->pos] : 0; +} + +static inline unsigned char peek_at(subject *subj, int pos) +{ + return subj->input.data[pos]; +} + +// Return true if there are more characters in the subject. +static inline int is_eof(subject* subj) +{ + return (subj->pos >= subj->input.len); +} + +// Advance the subject. Doesn't check for eof. +#define advance(subj) (subj)->pos += 1 + +// Take characters while a predicate holds, and return a string. +static inline cmark_chunk take_while(subject* subj, int (*f)(int)) +{ + unsigned char c; + int startpos = subj->pos; + int len = 0; + + while ((c = peek_char(subj)) && (*f)(c)) { + advance(subj); + len++; + } + + return cmark_chunk_dup(&subj->input, startpos, len); +} + +// Try to process a backtick code span that began with a +// span of ticks of length openticklength length (already +// parsed). Return 0 if you don't find matching closing +// backticks, otherwise return the position in the subject +// after the closing backticks. +static int scan_to_closing_backticks(subject* subj, int openticklength) +{ + // read non backticks + unsigned char c; + while ((c = peek_char(subj)) && c != '`') { + advance(subj); + } + if (is_eof(subj)) { + return 0; // did not find closing ticks, return 0 + } + int numticks = 0; + while (peek_char(subj) == '`') { + advance(subj); + numticks++; + } + if (numticks != openticklength) { + return(scan_to_closing_backticks(subj, openticklength)); + } + return (subj->pos); +} + +// Parse backtick code section or raw backticks, return an inline. +// Assumes that the subject has a backtick at the current position. +static cmark_node* handle_backticks(subject *subj) +{ + cmark_chunk openticks = take_while(subj, isbacktick); + int startpos = subj->pos; + int endpos = scan_to_closing_backticks(subj, openticks.len); + + if (endpos == 0) { // not found + subj->pos = startpos; // rewind + return make_str(openticks); + } else { + cmark_strbuf buf = GH_BUF_INIT; + + cmark_strbuf_set(&buf, subj->input.data + startpos, endpos - startpos - openticks.len); + cmark_strbuf_trim(&buf); + cmark_strbuf_normalize_whitespace(&buf); + + return make_code(cmark_chunk_buf_detach(&buf)); + } +} + +// Scan ***, **, or * and return number scanned, or 0. +// Advances position. +static int +scan_delims(subject* subj, unsigned char c, bool * can_open, bool * can_close) +{ + int numdelims = 0; + int before_char_pos; + int32_t after_char = 0; + int32_t before_char = 0; + int len; + bool left_flanking, right_flanking; + + if (subj->pos == 0) { + before_char = 10; + } else { + before_char_pos = subj->pos - 1; + // walk back to the beginning of the UTF_8 sequence: + while (peek_at(subj, before_char_pos) >> 6 == 2 && + before_char_pos > 0) { + before_char_pos -= 1; + } + len = utf8proc_iterate(subj->input.data + before_char_pos, + subj->pos - before_char_pos, &before_char); + if (len == -1) { + before_char = 10; + } + } + + if (c == '\'' || c == '"') { + numdelims++; + advance(subj); // limit to 1 delim for quotes + } else { + while (peek_char(subj) == c) { + numdelims++; + advance(subj); + } + } + + len = utf8proc_iterate(subj->input.data + subj->pos, + subj->input.len - subj->pos, &after_char); + if (len == -1) { + after_char = 10; + } + left_flanking = numdelims > 0 && !utf8proc_is_space(after_char) && + !(utf8proc_is_punctuation(after_char) && + !utf8proc_is_space(before_char) && + !utf8proc_is_punctuation(before_char)); + right_flanking = numdelims > 0 && !utf8proc_is_space(before_char) && + !(utf8proc_is_punctuation(before_char) && + !utf8proc_is_space(after_char) && + !utf8proc_is_punctuation(after_char)); + if (c == '_') { + *can_open = left_flanking && !right_flanking; + *can_close = right_flanking && !left_flanking; + } else if (c == '\'' || c == '"') { + *can_open = left_flanking && !right_flanking; + *can_close = right_flanking; + } else { + *can_open = left_flanking; + *can_close = right_flanking; + } + return numdelims; +} + +/* +static void print_delimiters(subject *subj) +{ + delimiter *delim; + delim = subj->last_delim; + while (delim != NULL) { + printf("Item at %p: %d %d %d next(%p) prev(%p)\n", + delim, delim->delim_char, + delim->can_open, delim->can_close, + delim->next, delim->previous); + delim = delim->previous; + } +} +*/ + +static void remove_delimiter(subject *subj, delimiter *delim) +{ + if (delim == NULL) return; + if (delim->next == NULL) { + // end of list: + assert(delim == subj->last_delim); + subj->last_delim = delim->previous; + } else { + delim->next->previous = delim->previous; + } + if (delim->previous != NULL) { + delim->previous->next = delim->next; + } + free(delim); +} + +static void push_delimiter(subject *subj, unsigned char c, bool can_open, + bool can_close, cmark_node *inl_text) +{ + delimiter *delim = + (delimiter*)malloc(sizeof(delimiter)); + if (delim == NULL) { + return; + } + delim->delim_char = c; + delim->can_open = can_open; + delim->can_close = can_close; + delim->inl_text = inl_text; + delim->previous = subj->last_delim; + delim->next = NULL; + if (delim->previous != NULL) { + delim->previous->next = delim; + } + delim->position = subj->pos; + delim->active = true; + subj->last_delim = delim; +} + +// Assumes the subject has a c at the current position. +static cmark_node* handle_delim(subject* subj, unsigned char c, bool smart) +{ + int numdelims; + cmark_node * inl_text; + bool can_open, can_close; + cmark_chunk contents; + + numdelims = scan_delims(subj, c, &can_open, &can_close); + + if (c == '\'' && smart) { + contents = cmark_chunk_literal(RIGHTSINGLEQUOTE); + } else if (c == '"' && smart) { + contents = cmark_chunk_literal(can_close ? RIGHTDOUBLEQUOTE : LEFTDOUBLEQUOTE); + } else { + contents = cmark_chunk_dup(&subj->input, subj->pos - numdelims, numdelims); + } + + inl_text = make_str(contents); + + if ((can_open || can_close) && + (!(c == '\'' || c == '"') || smart)) { + push_delimiter(subj, c, can_open, can_close, inl_text); + } + + return inl_text; +} + +// Assumes we have a hyphen at the current position. +static cmark_node* handle_hyphen(subject* subj, bool smart) +{ + advance(subj); + if (smart && peek_char(subj) == '-') { + advance(subj); + if (peek_char(subj) == '-') { + advance(subj); + return make_str(cmark_chunk_literal(EMDASH)); + } else { + return make_str(cmark_chunk_literal(ENDASH)); + } + } else { + return make_str(cmark_chunk_literal("-")); + } +} + +// Assumes we have a period at the current position. +static cmark_node* handle_period(subject* subj, bool smart) +{ + advance(subj); + if (smart && peek_char(subj) == '.') { + advance(subj); + if (peek_char(subj) == '.') { + advance(subj); + return make_str(cmark_chunk_literal(ELLIPSES)); + } else { + return make_str(cmark_chunk_literal("..")); + } + } else { + return make_str(cmark_chunk_literal(".")); + } +} + +static void process_emphasis(subject *subj, delimiter *start_delim) +{ + delimiter *closer = subj->last_delim; + delimiter *opener; + + // move back to first relevant delim. + while (closer != NULL && closer->previous != start_delim) { + closer = closer->previous; + } + + // now move forward, looking for closers, and handling each + while (closer != NULL) { + if (closer->can_close && + (closer->delim_char == '*' || closer->delim_char == '_' || + closer->delim_char == '"' || closer->delim_char == '\'')) { + // Now look backwards for first matching opener: + opener = closer->previous; + while (opener != NULL && opener != start_delim) { + if (opener->delim_char == closer->delim_char && + opener->can_open) { + break; + } + opener = opener->previous; + } + if (closer->delim_char == '*' || closer->delim_char == '_') { + if (opener != NULL && opener != start_delim) { + closer = S_insert_emph(subj, opener, closer); + } else { + closer = closer->next; + } + } else if (closer->delim_char == '\'') { + cmark_chunk_free(&closer->inl_text->as.literal); + closer->inl_text->as.literal = + cmark_chunk_literal(RIGHTSINGLEQUOTE); + if (opener != NULL && opener != start_delim) { + cmark_chunk_free(&opener->inl_text->as.literal); + opener->inl_text->as.literal = + cmark_chunk_literal(LEFTSINGLEQUOTE); + } + closer = closer->next; + } else if (closer->delim_char == '"') { + cmark_chunk_free(&closer->inl_text->as.literal); + closer->inl_text->as.literal = + cmark_chunk_literal(RIGHTDOUBLEQUOTE); + if (opener != NULL && opener != start_delim) { + cmark_chunk_free(&opener->inl_text->as.literal); + opener->inl_text->as.literal = + cmark_chunk_literal(LEFTDOUBLEQUOTE); + } + closer = closer->next; + } + } else { + closer = closer->next; + } + } + // free all delimiters in list until start_delim: + while (subj->last_delim != start_delim) { + remove_delimiter(subj, subj->last_delim); + } +} + +static delimiter* +S_insert_emph(subject *subj, delimiter *opener, delimiter *closer) +{ + delimiter *delim, *tmp_delim; + int use_delims; + cmark_node *opener_inl = opener->inl_text; + cmark_node *closer_inl = closer->inl_text; + int opener_num_chars = opener_inl->as.literal.len; + int closer_num_chars = closer_inl->as.literal.len; + cmark_node *tmp, *emph, *first_child, *last_child; + + // calculate the actual number of characters used from this closer + if (closer_num_chars < 3 || opener_num_chars < 3) { + use_delims = closer_num_chars <= opener_num_chars ? + closer_num_chars : opener_num_chars; + } else { // closer and opener both have >= 3 characters + use_delims = closer_num_chars % 2 == 0 ? 2 : 1; + } + + // remove used characters from associated inlines. + opener_num_chars -= use_delims; + closer_num_chars -= use_delims; + opener_inl->as.literal.len = opener_num_chars; + closer_inl->as.literal.len = closer_num_chars; + + // free delimiters between opener and closer + delim = closer->previous; + while (delim != NULL && delim != opener) { + tmp_delim = delim->previous; + remove_delimiter(subj, delim); + delim = tmp_delim; + } + + first_child = opener_inl->next; + last_child = closer_inl->prev; + + // if opener has 0 characters, remove it and its associated inline + if (opener_num_chars == 0) { + // replace empty opener inline with emph + cmark_chunk_free(&(opener_inl->as.literal)); + emph = opener_inl; + emph->type = use_delims == 1 ? NODE_EMPH : NODE_STRONG; + // remove opener from list + remove_delimiter(subj, opener); + } else { + // create new emph or strong, and splice it in to our inlines + // between the opener and closer + emph = use_delims == 1 ? make_emph() : make_strong(); + emph->parent = opener_inl->parent; + emph->prev = opener_inl; + opener_inl->next = emph; + } + + // push children below emph + emph->next = closer_inl; + closer_inl->prev = emph; + emph->first_child = first_child; + emph->last_child = last_child; + + // fix children pointers + first_child->prev = NULL; + last_child->next = NULL; + for (tmp = first_child; tmp != NULL; tmp = tmp->next) { + tmp->parent = emph; + } + + // if closer has 0 characters, remove it and its associated inline + if (closer_num_chars == 0) { + // remove empty closer inline + cmark_node_free(closer_inl); + // remove closer from list + tmp_delim = closer->next; + remove_delimiter(subj, closer); + closer = tmp_delim; + } + + return closer; +} + +// Parse backslash-escape or just a backslash, returning an inline. +static cmark_node* handle_backslash(subject *subj) +{ + advance(subj); + unsigned char nextchar = peek_char(subj); + if (cmark_ispunct(nextchar)) { // only ascii symbols and newline can be escaped + advance(subj); + return make_str(cmark_chunk_dup(&subj->input, subj->pos - 1, 1)); + } else if (nextchar == '\n') { + advance(subj); + return make_linebreak(); + } else { + return make_str(cmark_chunk_literal("\\")); + } +} + +// Parse an entity or a regular "&" string. +// Assumes the subject has an '&' character at the current position. +static cmark_node* handle_entity(subject* subj) +{ + cmark_strbuf ent = GH_BUF_INIT; + size_t len; + + advance(subj); + + len = houdini_unescape_ent(&ent, + subj->input.data + subj->pos, + subj->input.len - subj->pos + ); + + if (len == 0) + return make_str(cmark_chunk_literal("&")); + + subj->pos += len; + return make_str(cmark_chunk_buf_detach(&ent)); +} + +// Like make_str, but parses entities. +// Returns an inline sequence consisting of str and entity elements. +static cmark_node *make_str_with_entities(cmark_chunk *content) +{ + cmark_strbuf unescaped = GH_BUF_INIT; + + if (houdini_unescape_html(&unescaped, content->data, (size_t)content->len)) { + return make_str(cmark_chunk_buf_detach(&unescaped)); + } else { + return make_str(*content); + } +} + +// Clean a URL: remove surrounding whitespace and surrounding <>, +// and remove \ that escape punctuation. +unsigned char *cmark_clean_url(cmark_chunk *url) +{ + cmark_strbuf buf = GH_BUF_INIT; + + cmark_chunk_trim(url); + + if (url->len == 0) + return NULL; + + if (url->data[0] == '<' && url->data[url->len - 1] == '>') { + houdini_unescape_html_f(&buf, url->data + 1, url->len - 2); + } else { + houdini_unescape_html_f(&buf, url->data, url->len); + } + + cmark_strbuf_unescape(&buf); + return cmark_strbuf_detach(&buf); +} + +unsigned char *cmark_clean_title(cmark_chunk *title) +{ + cmark_strbuf buf = GH_BUF_INIT; + unsigned char first, last; + + if (title->len == 0) + return NULL; + + first = title->data[0]; + last = title->data[title->len - 1]; + + // remove surrounding quotes if any: + if ((first == '\'' && last == '\'') || + (first == '(' && last == ')') || + (first == '"' && last == '"')) { + houdini_unescape_html_f(&buf, title->data + 1, title->len - 2); + } else { + houdini_unescape_html_f(&buf, title->data, title->len); + } + + cmark_strbuf_unescape(&buf); + return cmark_strbuf_detach(&buf); +} + +// Parse an autolink or HTML tag. +// Assumes the subject has a '<' character at the current position. +static cmark_node* handle_pointy_brace(subject* subj) +{ + int matchlen = 0; + cmark_chunk contents; + + advance(subj); // advance past first < + + // first try to match a URL autolink + matchlen = scan_autolink_uri(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); + subj->pos += matchlen; + + return make_autolink( + make_str_with_entities(&contents), + contents, 0 + ); + } + + // next try to match an email autolink + matchlen = scan_autolink_email(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos, matchlen - 1); + subj->pos += matchlen; + + return make_autolink( + make_str_with_entities(&contents), + contents, 1 + ); + } + + // finally, try to match an html tag + matchlen = scan_html_tag(&subj->input, subj->pos); + if (matchlen > 0) { + contents = cmark_chunk_dup(&subj->input, subj->pos - 1, matchlen + 1); + subj->pos += matchlen; + return make_raw_html(contents); + } + + // if nothing matches, just return the opening <: + return make_str(cmark_chunk_literal("<")); +} + +// Parse a link label. Returns 1 if successful. +// Note: unescaped brackets are not allowed in labels. +// The label begins with `[` and ends with the first `]` character +// encountered. Backticks in labels do not start code spans. +static int link_label(subject* subj, cmark_chunk *raw_label) +{ + int startpos = subj->pos; + int length = 0; + unsigned char c; + + // advance past [ + if (peek_char(subj) == '[') { + advance(subj); + } else { + return 0; + } + + while ((c = peek_char(subj)) && c != '[' && c != ']') { + if (c == '\\') { + advance(subj); + length++; + if (cmark_ispunct(peek_char(subj))) { + advance(subj); + length++; + } + } else { + advance(subj); + length++; + } + if (length > MAX_LINK_LABEL_LENGTH) { + goto noMatch; + } + } + + if (c == ']') { // match found + *raw_label = cmark_chunk_dup(&subj->input, startpos + 1, subj->pos - (startpos + 1)); + advance(subj); // advance past ] + return 1; + } + +noMatch: + subj->pos = startpos; // rewind + return 0; + +} + +// Return a link, an image, or a literal close bracket. +static cmark_node* handle_close_bracket(subject* subj, cmark_node *parent) +{ + int initial_pos; + int starturl, endurl, starttitle, endtitle, endall; + int n; + int sps; + cmark_reference *ref; + bool is_image = false; + cmark_chunk url_chunk, title_chunk; + unsigned char *url, *title; + delimiter *opener; + cmark_node *link_text; + cmark_node *inl; + cmark_chunk raw_label; + int found_label; + + advance(subj); // advance past ] + initial_pos = subj->pos; + + // look through list of delimiters for a [ or ! + opener = subj->last_delim; + while (opener) { + if (opener->delim_char == '[' || opener->delim_char == '!') { + break; + } + opener = opener->previous; + } + + if (opener == NULL) { + return make_str(cmark_chunk_literal("]")); + } + + if (!opener->active) { + // take delimiter off stack + remove_delimiter(subj, opener); + return make_str(cmark_chunk_literal("]")); + } + + // If we got here, we matched a potential link/image text. + is_image = opener->delim_char == '!'; + link_text = opener->inl_text->next; + + // Now we check to see if it's a link/image. + + // First, look for an inline link. + if (peek_char(subj) == '(' && + ((sps = scan_spacechars(&subj->input, subj->pos + 1)) > -1) && + ((n = scan_link_url(&subj->input, subj->pos + 1 + sps)) > -1)) { + + // try to parse an explicit link: + starturl = subj->pos + 1 + sps; // after ( + endurl = starturl + n; + starttitle = endurl + scan_spacechars(&subj->input, endurl); + + // ensure there are spaces btw url and title + endtitle = (starttitle == endurl) ? starttitle : + starttitle + scan_link_title(&subj->input, starttitle); + + endall = endtitle + scan_spacechars(&subj->input, endtitle); + + if (peek_at(subj, endall) == ')') { + subj->pos = endall + 1; + + url_chunk = cmark_chunk_dup(&subj->input, starturl, endurl - starturl); + title_chunk = cmark_chunk_dup(&subj->input, starttitle, endtitle - starttitle); + url = cmark_clean_url(&url_chunk); + title = cmark_clean_title(&title_chunk); + cmark_chunk_free(&url_chunk); + cmark_chunk_free(&title_chunk); + goto match; + + } else { + goto noMatch; + } + } + + // Next, look for a following [link label] that matches in refmap. + // skip spaces + subj->pos = subj->pos + scan_spacechars(&subj->input, subj->pos); + raw_label = cmark_chunk_literal(""); + found_label = link_label(subj, &raw_label); + if (!found_label || raw_label.len == 0) { + cmark_chunk_free(&raw_label); + raw_label = cmark_chunk_dup(&subj->input, opener->position, + initial_pos - opener->position - 1); + } + + if (!found_label) { + // If we have a shortcut reference link, back up + // to before the spacse we skipped. + subj->pos = initial_pos; + } + + ref = cmark_reference_lookup(subj->refmap, &raw_label); + cmark_chunk_free(&raw_label); + + if (ref != NULL) { // found + url = bufdup(ref->url); + title = bufdup(ref->title); + goto match; + } else { + goto noMatch; + } + +noMatch: + // If we fall through to here, it means we didn't match a link: + remove_delimiter(subj, opener); // remove this opener from delimiter list + subj->pos = initial_pos; + return make_str(cmark_chunk_literal("]")); + +match: + inl = opener->inl_text; + inl->type = is_image ? NODE_IMAGE : NODE_LINK; + cmark_chunk_free(&inl->as.literal); + inl->first_child = link_text; + process_emphasis(subj, opener->previous); + inl->as.link.url = url; + inl->as.link.title = title; + inl->next = NULL; + if (link_text) { + cmark_node *tmp; + link_text->prev = NULL; + for (tmp = link_text; tmp->next != NULL; tmp = tmp->next) { + tmp->parent = inl; + } + tmp->parent = inl; + inl->last_child = tmp; + } + parent->last_child = inl; + + // process_emphasis will remove this delimiter and all later ones. + // Now, if we have a link, we also want to deactivate earlier link + // delimiters. (This code can be removed if we decide to allow links + // inside links.) + if (!is_image) { + opener = subj->last_delim; + while (opener != NULL) { + if (opener->delim_char == '[') { + if (!opener->active) { + break; + } else { + opener->active = false; + } + } + opener = opener->previous; + } + } + + return NULL; +} + +// Parse a hard or soft linebreak, returning an inline. +// Assumes the subject has a newline at the current position. +static cmark_node* handle_newline(subject *subj) +{ + int nlpos = subj->pos; + // skip over newline + advance(subj); + // skip spaces at beginning of line + while (peek_char(subj) == ' ') { + advance(subj); + } + if (nlpos > 1 && + peek_at(subj, nlpos - 1) == ' ' && + peek_at(subj, nlpos - 2) == ' ') { + return make_linebreak(); + } else { + return make_softbreak(); + } +} + +static int subject_find_special_char(subject *subj, int options) +{ + // "\n\\`&_*[]pos + 1; + + while (n < subj->input.len) { + if (SPECIAL_CHARS[subj->input.data[n]]) + return n; + if (options & CMARK_OPT_SMART && + SMART_PUNCT_CHARS[subj->input.data[n]]) + return n; + n++; + } + + return subj->input.len; +} + +// Parse an inline, advancing subject, and add it as a child of parent. +// Return 0 if no inline can be parsed, 1 otherwise. +static int parse_inline(subject* subj, cmark_node * parent, int options) +{ + cmark_node* new_inl = NULL; + cmark_chunk contents; + unsigned char c; + int endpos; + c = peek_char(subj); + if (c == 0) { + return 0; + } + switch(c) { + case '\n': + new_inl = handle_newline(subj); + break; + case '`': + new_inl = handle_backticks(subj); + break; + case '\\': + new_inl = handle_backslash(subj); + break; + case '&': + new_inl = handle_entity(subj); + break; + case '<': + new_inl = handle_pointy_brace(subj); + break; + case '*': + case '_': + case '\'': + case '"': + new_inl = handle_delim(subj, c, options & CMARK_OPT_SMART); + break; + case '-': + new_inl = handle_hyphen(subj, options & CMARK_OPT_SMART); + break; + case '.': + new_inl = handle_period(subj, options & CMARK_OPT_SMART); + break; + case '[': + advance(subj); + new_inl = make_str(cmark_chunk_literal("[")); + push_delimiter(subj, '[', true, false, new_inl); + break; + case ']': + new_inl = handle_close_bracket(subj, parent); + break; + case '!': + advance(subj); + if (peek_char(subj) == '[') { + advance(subj); + new_inl = make_str(cmark_chunk_literal("![")); + push_delimiter(subj, '!', false, true, new_inl); + } else { + new_inl = make_str(cmark_chunk_literal("!")); + } + break; + default: + endpos = subject_find_special_char(subj, options); + contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos); + subj->pos = endpos; + + // if we're at a newline, strip trailing spaces. + if (peek_char(subj) == '\n') { + cmark_chunk_rtrim(&contents); + } + + new_inl = make_str(contents); + } + if (new_inl != NULL) { + cmark_node_append_child(parent, new_inl); + } + + return 1; +} + +// Parse inlines from parent's string_content, adding as children of parent. +extern void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options) +{ + subject subj; + subject_from_buf(&subj, &parent->string_content, refmap); + + while (!is_eof(&subj) && parse_inline(&subj, parent, options)) ; + + process_emphasis(&subj, NULL); +} + +// Parse zero or more space characters, including at most one newline. +static void spnl(subject* subj) +{ + bool seen_newline = false; + while (peek_char(subj) == ' ' || + (!seen_newline && + (seen_newline = peek_char(subj) == '\n'))) { + advance(subj); + } +} + +// Parse reference. Assumes string begins with '[' character. +// Modify refmap if a reference is encountered. +// Return 0 if no reference found, otherwise position of subject +// after reference is parsed. +int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap) +{ + subject subj; + + cmark_chunk lab; + cmark_chunk url; + cmark_chunk title; + + int matchlen = 0; + int beforetitle; + + subject_from_buf(&subj, input, NULL); + + // parse label: + if (!link_label(&subj, &lab)) + return 0; + + // colon: + if (peek_char(&subj) == ':') { + advance(&subj); + } else { + return 0; + } + + // parse link url: + spnl(&subj); + matchlen = scan_link_url(&subj.input, subj.pos); + if (matchlen) { + url = cmark_chunk_dup(&subj.input, subj.pos, matchlen); + subj.pos += matchlen; + } else { + return 0; + } + + // parse optional link_title + beforetitle = subj.pos; + spnl(&subj); + matchlen = scan_link_title(&subj.input, subj.pos); + if (matchlen) { + title = cmark_chunk_dup(&subj.input, subj.pos, matchlen); + subj.pos += matchlen; + } else { + subj.pos = beforetitle; + title = cmark_chunk_literal(""); + } + // parse final spaces and newline: + while (peek_char(&subj) == ' ') { + advance(&subj); + } + if (peek_char(&subj) == '\n') { + advance(&subj); + } else if (peek_char(&subj) != 0) { + return 0; + } + // insert reference into refmap + cmark_reference_create(refmap, &lab, &url, &title); + return subj.pos; +} diff --git a/cmark/inlines.h b/cmark/inlines.h new file mode 100644 --- /dev/null +++ b/cmark/inlines.h @@ -0,0 +1,19 @@ +#ifndef CMARK_INLINES_H +#define CMARK_INLINES_H + +#ifdef __cplusplus +extern "C" { +#endif + +unsigned char *cmark_clean_url(cmark_chunk *url); +unsigned char *cmark_clean_title(cmark_chunk *title); + +void cmark_parse_inlines(cmark_node* parent, cmark_reference_map *refmap, int options); + +int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/iterator.c b/cmark/iterator.c new file mode 100644 --- /dev/null +++ b/cmark/iterator.c @@ -0,0 +1,146 @@ +#include +#include + +#include "config.h" +#include "node.h" +#include "cmark.h" +#include "iterator.h" + +static const int S_leaf_mask = + (1 << CMARK_NODE_HTML) | + (1 << CMARK_NODE_HRULE) | + (1 << CMARK_NODE_CODE_BLOCK) | + (1 << CMARK_NODE_TEXT) | + (1 << CMARK_NODE_SOFTBREAK) | + (1 << CMARK_NODE_LINEBREAK) | + (1 << CMARK_NODE_CODE) | + (1 << CMARK_NODE_INLINE_HTML); + +cmark_iter* +cmark_iter_new(cmark_node *root) +{ + if (root == NULL) { + return NULL; + } + cmark_iter *iter = (cmark_iter*)malloc(sizeof(cmark_iter)); + if (iter == NULL) { + return NULL; + } + iter->root = root; + iter->cur.ev_type = CMARK_EVENT_NONE; + iter->cur.node = NULL; + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = root; + return iter; +} + +void +cmark_iter_free(cmark_iter *iter) +{ + free(iter); +} + +static bool +S_is_leaf(cmark_node *node) +{ + return (1 << node->type) & S_leaf_mask; +} + +cmark_event_type +cmark_iter_next(cmark_iter *iter) +{ + cmark_event_type ev_type = iter->next.ev_type; + cmark_node *node = iter->next.node; + + iter->cur.ev_type = ev_type; + iter->cur.node = node; + + if (ev_type == CMARK_EVENT_DONE) { + return ev_type; + } + + /* roll forward to next item, setting both fields */ + if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) { + if (node->first_child == NULL) { + /* stay on this node but exit */ + iter->next.ev_type = CMARK_EVENT_EXIT; + } else { + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = node->first_child; + } + } else if (node == iter->root) { + /* don't move past root */ + iter->next.ev_type = CMARK_EVENT_DONE; + iter->next.node = NULL; + } else if (node->next) { + iter->next.ev_type = CMARK_EVENT_ENTER; + iter->next.node = node->next; + } else if (node->parent) { + iter->next.ev_type = CMARK_EVENT_EXIT; + iter->next.node = node->parent; + } else { + assert(false); + iter->next.ev_type = CMARK_EVENT_DONE; + iter->next.node = NULL; + } + + return ev_type; +} + +void +cmark_iter_reset(cmark_iter *iter, cmark_node *current, + cmark_event_type event_type) +{ + iter->next.ev_type = event_type; + iter->next.node = current; + cmark_iter_next(iter); +} + +cmark_node* +cmark_iter_get_node(cmark_iter *iter) +{ + return iter->cur.node; +} + +cmark_event_type +cmark_iter_get_event_type(cmark_iter *iter) +{ + return iter->cur.ev_type; +} + +cmark_node* +cmark_iter_get_root(cmark_iter *iter) +{ + return iter->root; +} + + +void cmark_consolidate_text_nodes(cmark_node *root) +{ + cmark_iter *iter = cmark_iter_new(root); + cmark_strbuf buf = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur, *tmp, *next; + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + if (ev_type == CMARK_EVENT_ENTER && + cur->type == CMARK_NODE_TEXT && + cur->next && + cur->next->type == CMARK_NODE_TEXT) { + cmark_strbuf_clear(&buf); + cmark_strbuf_puts(&buf, cmark_node_get_literal(cur)); + tmp = cur->next; + while (tmp && tmp->type == CMARK_NODE_TEXT) { + cmark_iter_next(iter); // advance pointer + cmark_strbuf_puts(&buf, cmark_node_get_literal(tmp)); + next = tmp->next; + cmark_node_free(tmp); + tmp = next; + } + cmark_node_set_literal(cur, (char *)cmark_strbuf_detach(&buf)); + } + } + + cmark_iter_free(iter); +} diff --git a/cmark/iterator.h b/cmark/iterator.h new file mode 100644 --- /dev/null +++ b/cmark/iterator.h @@ -0,0 +1,25 @@ +#ifndef CMARK_ITERATOR_H +#define CMARK_ITERATOR_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "cmark.h" + +typedef struct { + cmark_event_type ev_type; + cmark_node *node; +} cmark_iter_state; + +struct cmark_iter { + cmark_node *root; + cmark_iter_state cur; + cmark_iter_state next; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/main.c b/cmark/main.c new file mode 100644 --- /dev/null +++ b/cmark/main.c @@ -0,0 +1,166 @@ +#include +#include +#include +#include +#include "config.h" +#include "cmark.h" +#include "debug.h" +#include "bench.h" + +#if defined(_WIN32) && !defined(__CYGWIN__) +#include +#include +#endif + +typedef enum { + FORMAT_NONE, + FORMAT_HTML, + FORMAT_XML, + FORMAT_MAN, +} writer_format; + +void print_usage() +{ + printf("Usage: cmark [FILE*]\n"); + printf("Options:\n"); + printf(" --to, -t FORMAT Specify output format (html, xml, man)\n"); + printf(" --sourcepos Include source position attribute\n"); + printf(" --hardbreaks Treat newlines as hard line breaks\n"); + printf(" --smart Use smart punctuation\n"); + printf(" --normalize Consolidate adjacent text nodes\n"); + printf(" --help, -h Print usage information\n"); + printf(" --version Print version\n"); +} + +static void print_document(cmark_node *document, writer_format writer, + int options) +{ + char *result; + switch (writer) { + case FORMAT_HTML: + result = cmark_render_html(document, options); + break; + case FORMAT_XML: + result = cmark_render_xml(document, options); + break; + case FORMAT_MAN: + result = cmark_render_man(document, options); + break; + default: + fprintf(stderr, "Unknown format %d\n", writer); + exit(1); + } + printf("%s", result); + free(result); +} + +int main(int argc, char *argv[]) +{ + int i, numfps = 0; + int *files; + char buffer[4096]; + cmark_parser *parser; + size_t bytes; + cmark_node *document; + writer_format writer = FORMAT_HTML; + int options = CMARK_OPT_DEFAULT; + +#if defined(_WIN32) && !defined(__CYGWIN__) + _setmode(_fileno(stdout), _O_BINARY); +#endif + + files = (int *)malloc(argc * sizeof(*files)); + + for (i = 1; i < argc; i++) { + if (strcmp(argv[i], "--version") == 0) { + printf("cmark %s", CMARK_VERSION_STRING); + printf(" - CommonMark converter (c) 2014 John MacFarlane\n"); + exit(0); + } else if (strcmp(argv[i], "--sourcepos") == 0) { + options |= CMARK_OPT_SOURCEPOS; + } else if (strcmp(argv[i], "--hardbreaks") == 0) { + options |= CMARK_OPT_HARDBREAKS; + } else if (strcmp(argv[i], "--smart") == 0) { + options |= CMARK_OPT_SMART; + } else if (strcmp(argv[i], "--normalize") == 0) { + options |= CMARK_OPT_NORMALIZE; + } else if ((strcmp(argv[i], "--help") == 0) || + (strcmp(argv[i], "-h") == 0)) { + print_usage(); + exit(0); + } else if ((strcmp(argv[i], "-t") == 0) || + (strcmp(argv[i], "--to") == 0)) { + i += 1; + if (i < argc) { + if (strcmp(argv[i], "man") == 0) { + writer = FORMAT_MAN; + } else if (strcmp(argv[i], "html") == 0) { + writer = FORMAT_HTML; + } else if (strcmp(argv[i], "xml") == 0) { + writer = FORMAT_XML; + } else { + fprintf(stderr, + "Unknown format %s\n", argv[i]); + exit(1); + } + } else { + fprintf(stderr, "No argument provided for %s\n", + argv[i - 1]); + exit(1); + } + } else if (*argv[i] == '-') { + print_usage(); + exit(1); + } else { // treat as file argument + files[numfps++] = i; + } + } + + parser = cmark_parser_new(options); + for (i = 0; i < numfps; i++) { + FILE *fp = fopen(argv[files[i]], "r"); + if (fp == NULL) { + fprintf(stderr, "Error opening file %s: %s\n", + argv[files[i]], strerror(errno)); + exit(1); + } + + start_timer(); + while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) { + cmark_parser_feed(parser, buffer, bytes); + if (bytes < sizeof(buffer)) { + break; + } + } + end_timer("processing lines"); + + fclose(fp); + } + + if (numfps == 0) { + + while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0) { + cmark_parser_feed(parser, buffer, bytes); + if (bytes < sizeof(buffer)) { + break; + } + } + } + + start_timer(); + document = cmark_parser_finish(parser); + end_timer("finishing document"); + cmark_parser_free(parser); + + start_timer(); + print_document(document, writer, options); + end_timer("print_document"); + + start_timer(); + cmark_node_free(document); + end_timer("free_blocks"); + + free(files); + + return 0; +} diff --git a/cmark/man.c b/cmark/man.c new file mode 100644 --- /dev/null +++ b/cmark/man.c @@ -0,0 +1,284 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "utf8.h" + +// Functions to convert cmark_nodes to groff man strings. + +static void escape_man(cmark_strbuf *dest, const unsigned char *source, int length) +{ + int32_t c; + int i = 0; + int len; + bool beginLine = true; + + while (i < length) { + len = utf8proc_iterate(source + i, length - i, &c); + switch(c) { + case 46: + if (beginLine) { + cmark_strbuf_puts(dest, "\\&."); + } else { + utf8proc_encode_char(c, dest); + } + break; + case 39: + if (beginLine) { + cmark_strbuf_puts(dest, "\\&'"); + } else { + utf8proc_encode_char(c, dest); + } + break; + case 45: + cmark_strbuf_puts(dest, "\\-"); + break; + case 92: + cmark_strbuf_puts(dest, "\\e"); + break; + case 8216: // left single quote + cmark_strbuf_puts(dest, "\\[oq]"); + break; + case 8217: // right single quote + cmark_strbuf_puts(dest, "\\[cq]"); + break; + case 8220: // left double quote + cmark_strbuf_puts(dest, "\\[lq]"); + break; + case 8221: // right double quote + cmark_strbuf_puts(dest, "\\[rq]"); + break; + case 8212: // em dash + cmark_strbuf_puts(dest, "\\[em]"); + break; + case 8211: // en dash + cmark_strbuf_puts(dest, "\\[en]"); + break; + default: + utf8proc_encode_char(c, dest); + } + beginLine = (c == 10); + i += len; + } +} + +static inline void cr(cmark_strbuf *man) +{ + if (man->size && man->ptr[man->size - 1] != '\n') + cmark_strbuf_putc(man, '\n'); +} + +struct render_state { + cmark_strbuf* man; + cmark_node *plain; +}; + +static int +S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state) +{ + cmark_node *tmp; + cmark_strbuf *man = state->man; + int list_number; + bool entering = (ev_type == CMARK_EVENT_ENTER); + + if (state->plain == node) { // back at original node + state->plain = NULL; + } + + if (state->plain != NULL) { + switch(node->type) { + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + escape_man(man, node->as.literal.data, + node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + case CMARK_NODE_SOFTBREAK: + cmark_strbuf_putc(man, ' '); + break; + + default: + break; + } + return 1; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + break; + + case CMARK_NODE_BLOCK_QUOTE: + if (entering) { + cr(man); + cmark_strbuf_puts(man, ".RS"); + cr(man); + } else { + cr(man); + cmark_strbuf_puts(man, ".RE"); + cr(man); + } + break; + + case CMARK_NODE_LIST: + break; + + case CMARK_NODE_ITEM: + if (entering) { + cr(man); + cmark_strbuf_puts(man, ".IP "); + if (cmark_node_get_list_type(node->parent) == + CMARK_BULLET_LIST) { + cmark_strbuf_puts(man, "\\[bu] 2"); + } else { + list_number = cmark_node_get_list_start(node->parent); + tmp = node; + while (tmp->prev) { + tmp = tmp->prev; + list_number += 1; + } + cmark_strbuf_printf(man, "\"%d.\" 4", list_number); + } + cr(man); + } else { + cr(man); + } + break; + + case CMARK_NODE_HEADER: + if (entering) { + cr(man); + cmark_strbuf_puts(man, + cmark_node_get_header_level(node) == 1 ? + ".SH" : ".SS"); + cr(man); + } else { + cr(man); + } + break; + + case CMARK_NODE_CODE_BLOCK: + cr(man); + cmark_strbuf_puts(man, ".IP\n.nf\n\\f[C]\n"); + escape_man(man, node->as.code.literal.data, + node->as.code.literal.len); + cr(man); + cmark_strbuf_puts(man, "\\f[]\n.fi"); + cr(man); + break; + + case CMARK_NODE_HTML: + break; + + case CMARK_NODE_HRULE: + cr(man); + cmark_strbuf_puts(man, ".PP\n * * * * *"); + cr(man); + break; + + case CMARK_NODE_PARAGRAPH: + if (entering) { + // no blank line if first paragraph in list: + if (node->parent && + node->parent->type == CMARK_NODE_ITEM && + node->prev == NULL) { + // no blank line or .PP + } else { + cr(man); + cmark_strbuf_puts(man, ".PP\n"); + } + } else { + cr(man); + } + break; + + case CMARK_NODE_TEXT: + escape_man(man, node->as.literal.data, + node->as.literal.len); + break; + + case CMARK_NODE_LINEBREAK: + cmark_strbuf_puts(man, ".PD 0\n.P\n.PD"); + cr(man); + break; + + case CMARK_NODE_SOFTBREAK: + cmark_strbuf_putc(man, '\n'); + break; + + case CMARK_NODE_CODE: + cmark_strbuf_puts(man, "\\f[C]"); + escape_man(man, node->as.literal.data, node->as.literal.len); + cmark_strbuf_puts(man, "\\f[]"); + break; + + case CMARK_NODE_INLINE_HTML: + break; + + case CMARK_NODE_STRONG: + if (entering) { + cmark_strbuf_puts(man, "\\f[B]"); + } else { + cmark_strbuf_puts(man, "\\f[]"); + } + break; + + case CMARK_NODE_EMPH: + if (entering) { + cmark_strbuf_puts(man, "\\f[I]"); + } else { + cmark_strbuf_puts(man, "\\f[]"); + } + break; + + case CMARK_NODE_LINK: + if (!entering) { + cmark_strbuf_printf(man, " (%s)", + cmark_node_get_url(node)); + } + break; + + case CMARK_NODE_IMAGE: + if (entering) { + cmark_strbuf_puts(man, "[IMAGE: "); + state->plain = node; + } else { + cmark_strbuf_puts(man, "]"); + } + break; + + default: + assert(false); + break; + } + + // cmark_strbuf_putc(man, 'x'); + return 1; +} + +char *cmark_render_man(cmark_node *root, int options) +{ + char *result; + cmark_strbuf man = GH_BUF_INIT; + struct render_state state = { &man, NULL }; + cmark_node *cur; + cmark_event_type ev_type; + cmark_iter *iter = cmark_iter_new(root); + + if (options == 0) options = 0; // avoid warning about unused parameters + + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state); + } + result = (char *)cmark_strbuf_detach(&man); + + cmark_iter_free(iter); + return result; +} diff --git a/cmark/node.c b/cmark/node.c new file mode 100644 --- /dev/null +++ b/cmark/node.c @@ -0,0 +1,873 @@ +#include +#include + +#include "config.h" +#include "node.h" + +static void +S_node_unlink(cmark_node *node); + +static inline bool +S_is_block(cmark_node *node) +{ + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_BLOCK + && node->type <= CMARK_NODE_LAST_BLOCK; +} + +static inline bool +S_is_inline(cmark_node *node) +{ + if (node == NULL) { + return false; + } + return node->type >= CMARK_NODE_FIRST_INLINE + && node->type <= CMARK_NODE_LAST_INLINE; +} + +static bool +S_can_contain(cmark_node *node, cmark_node *child) +{ + cmark_node *cur; + + if (node == NULL || child == NULL) { + return false; + } + + // Verify that child is not an ancestor of node or equal to node. + cur = node; + do { + if (cur == child) { + return false; + } + cur = cur->parent; + } while (cur != NULL); + + if (child->type == CMARK_NODE_DOCUMENT) { + return false; + } + + switch (node->type) { + case CMARK_NODE_DOCUMENT: + case CMARK_NODE_BLOCK_QUOTE: + case CMARK_NODE_ITEM: + return S_is_block(child) + && child->type != CMARK_NODE_ITEM; + + case CMARK_NODE_LIST: + return child->type == CMARK_NODE_ITEM; + + case CMARK_NODE_PARAGRAPH: + case CMARK_NODE_HEADER: + case CMARK_NODE_EMPH: + case CMARK_NODE_STRONG: + case CMARK_NODE_LINK: + case CMARK_NODE_IMAGE: + return S_is_inline(child); + + default: + break; + } + + return false; +} + +cmark_node* +cmark_node_new(cmark_node_type type) +{ + cmark_node *node = (cmark_node *)calloc(1, sizeof(*node)); + node->type = type; + + switch (node->type) { + case CMARK_NODE_HEADER: + node->as.header.level = 1; + break; + + case CMARK_NODE_LIST: { + cmark_list *list = &node->as.list; + list->list_type = CMARK_BULLET_LIST; + list->start = 1; + list->tight = false; + break; + } + + default: + break; + } + + return node; +} + +// Free a cmark_node list and any children. +static +void S_free_nodes(cmark_node *e) +{ + cmark_node *next; + while (e != NULL) { + if (S_is_block(e)) { + cmark_strbuf_free(&e->string_content); + } + switch (e->type) { + case NODE_CODE_BLOCK: + cmark_chunk_free(&e->as.code.info); + cmark_chunk_free(&e->as.code.literal); + break; + case NODE_TEXT: + case NODE_INLINE_HTML: + case NODE_CODE: + case NODE_HTML: + cmark_chunk_free(&e->as.literal); + break; + case NODE_LINK: + case NODE_IMAGE: + if (e->as.link.url) { + free(e->as.link.url); + } + if (e->as.link.title) { + free(e->as.link.title); + } + break; + default: + break; + } + if (e->last_child) { + // Splice children into list + e->last_child->next = e->next; + e->next = e->first_child; + } + next = e->next; + free(e); + e = next; + } +} + +void +cmark_node_free(cmark_node *node) +{ + S_node_unlink(node); + node->next = NULL; + S_free_nodes(node); +} + +cmark_node_type +cmark_node_get_type(cmark_node *node) +{ + if (node == NULL) { + return CMARK_NODE_NONE; + } else { + return node->type; + } +} + +const char* +cmark_node_get_type_string(cmark_node *node) +{ + if (node == NULL) { + return "NONE"; + } + + switch (node->type) { + case CMARK_NODE_NONE: + return "none"; + case CMARK_NODE_DOCUMENT: + return "document"; + case CMARK_NODE_BLOCK_QUOTE: + return "block_quote"; + case CMARK_NODE_LIST: + return "list"; + case CMARK_NODE_ITEM: + return "item"; + case CMARK_NODE_CODE_BLOCK: + return "code_block"; + case CMARK_NODE_HTML: + return "html"; + case CMARK_NODE_PARAGRAPH: + return "paragraph"; + case CMARK_NODE_HEADER: + return "header"; + case CMARK_NODE_HRULE: + return "hrule"; + case CMARK_NODE_TEXT: + return "text"; + case CMARK_NODE_SOFTBREAK: + return "softbreak"; + case CMARK_NODE_LINEBREAK: + return "linebreak"; + case CMARK_NODE_CODE: + return "code"; + case CMARK_NODE_INLINE_HTML: + return "inline_html"; + case CMARK_NODE_EMPH: + return "emph"; + case CMARK_NODE_STRONG: + return "strong"; + case CMARK_NODE_LINK: + return "link"; + case CMARK_NODE_IMAGE: + return "image"; + } + + return ""; +} + +cmark_node* +cmark_node_next(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->next; + } +} + +cmark_node* +cmark_node_previous(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->prev; + } +} + +cmark_node* +cmark_node_parent(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->parent; + } +} + +cmark_node* +cmark_node_first_child(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->first_child; + } +} + +cmark_node* +cmark_node_last_child(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->last_child; + } +} + +void* +cmark_node_get_user_data(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } else { + return node->user_data; + } +} + +int +cmark_node_set_user_data(cmark_node *node, void *user_data) +{ + if (node == NULL) { + return 0; + } + node->user_data = user_data; + return 1; +} + +static char* +S_strdup(const char *str) +{ + size_t size = strlen(str) + 1; + char *dup = (char *)malloc(size); + memcpy(dup, str, size); + return dup; +} + +const char* +cmark_node_get_literal(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case NODE_HTML: + case NODE_TEXT: + case NODE_INLINE_HTML: + case NODE_CODE: + return cmark_chunk_to_cstr(&node->as.literal); + + case NODE_CODE_BLOCK: + return cmark_chunk_to_cstr(&node->as.code.literal); + + default: + break; + } + + return NULL; +} + +int +cmark_node_set_literal(cmark_node *node, const char *content) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case NODE_HTML: + case NODE_TEXT: + case NODE_INLINE_HTML: + case NODE_CODE: + cmark_chunk_set_cstr(&node->as.literal, content); + return 1; + + case NODE_CODE_BLOCK: + cmark_chunk_set_cstr(&node->as.code.literal, content); + return 1; + + default: + break; + } + + return 0; +} + +int +cmark_node_get_header_level(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HEADER: + return node->as.header.level; + + default: + break; + } + + return 0; +} + +int +cmark_node_set_header_level(cmark_node *node, int level) +{ + if (node == NULL || level < 1 || level > 6) { + return 0; + } + + switch (node->type) { + case CMARK_NODE_HEADER: + node->as.header.level = level; + return 1; + + default: + break; + } + + return 0; +} + +cmark_list_type +cmark_node_get_list_type(cmark_node *node) +{ + if (node == NULL) { + return CMARK_NO_LIST; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.list_type; + } else { + return CMARK_NO_LIST; + } +} + +int +cmark_node_set_list_type(cmark_node *node, cmark_list_type type) +{ + if (!(type == CMARK_BULLET_LIST || type == CMARK_ORDERED_LIST)) { + return 0; + } + + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.list_type = type; + return 1; + } else { + return 0; + } +} + +cmark_delim_type +cmark_node_get_list_delim(cmark_node *node) +{ + if (node == NULL) { + return CMARK_NO_DELIM; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.delimiter; + } else { + return CMARK_NO_DELIM; + } +} + +int +cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) +{ + if (!(delim == CMARK_PERIOD_DELIM || delim == CMARK_PAREN_DELIM)) { + return 0; + } + + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.delimiter = delim; + return 1; + } else { + return 0; + } +} + +int +cmark_node_get_list_start(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.start; + } else { + return 0; + } +} + +int +cmark_node_set_list_start(cmark_node *node, int start) +{ + if (node == NULL || start < 0) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.start = start; + return 1; + } else { + return 0; + } +} + +int +cmark_node_get_list_tight(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + return node->as.list.tight; + } else { + return 0; + } +} + +int +cmark_node_set_list_tight(cmark_node *node, int tight) +{ + if (node == NULL) { + return 0; + } + + if (node->type == CMARK_NODE_LIST) { + node->as.list.tight = tight; + return 1; + } else { + return 0; + } +} + +const char* +cmark_node_get_fence_info(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + if (node->type == NODE_CODE_BLOCK) { + return cmark_chunk_to_cstr(&node->as.code.info); + } else { + return NULL; + } +} + +int +cmark_node_set_fence_info(cmark_node *node, const char *info) +{ + if (node == NULL) { + return 0; + } + + if (node->type == NODE_CODE_BLOCK) { + cmark_chunk_set_cstr(&node->as.code.info, info); + return 1; + } else { + return 0; + } +} + +const char* +cmark_node_get_url(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + return (char *)node->as.link.url; + default: + break; + } + + return NULL; +} + +int +cmark_node_set_url(cmark_node *node, const char *url) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + free(node->as.link.url); + node->as.link.url = (unsigned char *)S_strdup(url); + return 1; + default: + break; + } + + return 0; +} + +const char* +cmark_node_get_title(cmark_node *node) +{ + if (node == NULL) { + return NULL; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + return (char *)node->as.link.title; + default: + break; + } + + return NULL; +} + +int +cmark_node_set_title(cmark_node *node, const char *title) +{ + if (node == NULL) { + return 0; + } + + switch (node->type) { + case NODE_LINK: + case NODE_IMAGE: + free(node->as.link.title); + node->as.link.title = (unsigned char *)S_strdup(title); + return 1; + default: + break; + } + + return 0; +} + +int +cmark_node_get_start_line(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->start_line; +} + +int +cmark_node_get_start_column(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->start_column; +} + +int +cmark_node_get_end_line(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->end_line; +} + +int +cmark_node_get_end_column(cmark_node *node) +{ + if (node == NULL) { + return 0; + } + return node->end_column; +} + +// Unlink a node without adjusting its next, prev, and parent pointers. +static void +S_node_unlink(cmark_node *node) +{ + if (node == NULL) { + return; + } + + if (node->prev) { + node->prev->next = node->next; + } + if (node->next) { + node->next->prev = node->prev; + } + + // Adjust first_child and last_child of parent. + cmark_node *parent = node->parent; + if (parent) { + if (parent->first_child == node) { + parent->first_child = node->next; + } + if (parent->last_child == node) { + parent->last_child = node->prev; + } + } +} + +void +cmark_node_unlink(cmark_node *node) +{ + S_node_unlink(node); + + node->next = NULL; + node->prev = NULL; + node->parent = NULL; + +} + +int +cmark_node_insert_before(cmark_node *node, cmark_node *sibling) +{ + if (node == NULL || sibling == NULL) { + return 0; + } + + if (!node->parent || !S_can_contain(node->parent, sibling)) { + return 0; + } + + S_node_unlink(sibling); + + cmark_node *old_prev = node->prev; + + // Insert 'sibling' between 'old_prev' and 'node'. + if (old_prev) { + old_prev->next = sibling; + } + sibling->prev = old_prev; + sibling->next = node; + node->prev = sibling; + + // Set new parent. + cmark_node *parent = node->parent; + sibling->parent = parent; + + // Adjust first_child of parent if inserted as first child. + if (parent && !old_prev) { + parent->first_child = sibling; + } + + return 1; +} + +int +cmark_node_insert_after(cmark_node *node, cmark_node *sibling) +{ + if (node == NULL || sibling == NULL) { + return 0; + } + + if (!node->parent || !S_can_contain(node->parent, sibling)) { + return 0; + } + + S_node_unlink(sibling); + + cmark_node *old_next = node->next; + + // Insert 'sibling' between 'node' and 'old_next'. + if (old_next) { + old_next->prev = sibling; + } + sibling->next = old_next; + sibling->prev = node; + node->next = sibling; + + // Set new parent. + cmark_node *parent = node->parent; + sibling->parent = parent; + + // Adjust last_child of parent if inserted as last child. + if (parent && !old_next) { + parent->last_child = sibling; + } + + return 1; +} + +int +cmark_node_prepend_child(cmark_node *node, cmark_node *child) +{ + if (!S_can_contain(node, child)) { + return 0; + } + + S_node_unlink(child); + + cmark_node *old_first_child = node->first_child; + + child->next = old_first_child; + child->prev = NULL; + child->parent = node; + node->first_child = child; + + if (old_first_child) { + old_first_child->prev = child; + } else { + // Also set last_child if node previously had no children. + node->last_child = child; + } + + return 1; +} + +int +cmark_node_append_child(cmark_node *node, cmark_node *child) +{ + if (!S_can_contain(node, child)) { + return 0; + } + + S_node_unlink(child); + + cmark_node *old_last_child = node->last_child; + + child->next = NULL; + child->prev = old_last_child; + child->parent = node; + node->last_child = child; + + if (old_last_child) { + old_last_child->next = child; + } else { + // Also set first_child if node previously had no children. + node->first_child = child; + } + + return 1; +} + +static void +S_print_error(FILE *out, cmark_node *node, const char *elem) +{ + if (out == NULL) { + return; + } + fprintf(out, "Invalid '%s' in node type %s at %d:%d\n", elem, + cmark_node_get_type_string(node), node->start_line, + node->start_column); +} + +int +cmark_node_check(cmark_node *node, FILE *out) +{ + cmark_node *cur; + int errors = 0; + + if (!node) { + return 0; + } + + cur = node; + while (true) { + if (cur->first_child) { + if (cur->first_child->prev != NULL) { + S_print_error(out, cur->first_child, "prev"); + cur->first_child->prev = NULL; + ++errors; + } + if (cur->first_child->parent != cur) { + S_print_error(out, cur->first_child, "parent"); + cur->first_child->parent = cur; + ++errors; + } + cur = cur->first_child; + continue; + } + +next_sibling: + if (cur == node) { + break; + } + if (cur->next) { + if (cur->next->prev != cur) { + S_print_error(out, cur->next, "prev"); + cur->next->prev = cur; + ++errors; + } + if (cur->next->parent != cur->parent) { + S_print_error(out, cur->next, "parent"); + cur->next->parent = cur->parent; + ++errors; + } + cur = cur->next; + continue; + } + + if (cur->parent->last_child != cur) { + S_print_error(out, cur->parent, "last_child"); + cur->parent->last_child = cur; + ++errors; + } + cur = cur->parent; + goto next_sibling; + } + + return errors; +} diff --git a/cmark/node.h b/cmark/node.h new file mode 100644 --- /dev/null +++ b/cmark/node.h @@ -0,0 +1,82 @@ +#ifndef CMARK_NODE_H +#define CMARK_NODE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "cmark.h" +#include "buffer.h" +#include "chunk.h" + +typedef struct { + cmark_list_type list_type; + int marker_offset; + int padding; + int start; + cmark_delim_type delimiter; + unsigned char bullet_char; + bool tight; +} cmark_list; + +typedef struct { + cmark_chunk info; + cmark_chunk literal; + int fence_length; + /* fence_offset must be 0-3, so we can use int8_t */ + int8_t fence_offset; + unsigned char fence_char; + bool fenced; +} cmark_code; + +typedef struct { + int level; + bool setext; +} cmark_header; + +typedef struct { + unsigned char *url; + unsigned char *title; +} cmark_link; + +struct cmark_node { + struct cmark_node *next; + struct cmark_node *prev; + struct cmark_node *parent; + struct cmark_node *first_child; + struct cmark_node *last_child; + + void *user_data; + + int start_line; + int start_column; + int end_line; + int end_column; + + cmark_node_type type; + + bool open; + bool last_line_blank; + + cmark_strbuf string_content; + + union { + cmark_chunk literal; + cmark_list list; + cmark_code code; + cmark_header header; + cmark_link link; + } as; +}; + +CMARK_EXPORT int +cmark_node_check(cmark_node *node, FILE *out); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/parser.h b/cmark/parser.h new file mode 100644 --- /dev/null +++ b/cmark/parser.h @@ -0,0 +1,29 @@ +#ifndef CMARK_AST_H +#define CMARK_AST_H + +#include +#include "node.h" +#include "buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MAX_LINK_LABEL_LENGTH 1000 + +struct cmark_parser { + struct cmark_reference_map *refmap; + struct cmark_node* root; + struct cmark_node* current; + int line_number; + cmark_strbuf *curline; + int last_line_length; + cmark_strbuf *linebuf; + int options; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/references.c b/cmark/references.c new file mode 100644 --- /dev/null +++ b/cmark/references.c @@ -0,0 +1,154 @@ +#include "cmark.h" +#include "utf8.h" +#include "parser.h" +#include "references.h" +#include "inlines.h" +#include "chunk.h" + +static unsigned int +refhash(const unsigned char *link_ref) +{ + unsigned int hash = 0; + + while (*link_ref) + hash = (*link_ref++) + (hash << 6) + (hash << 16) - hash; + + return hash; +} + +static void reference_free(cmark_reference *ref) +{ + if(ref != NULL) { + free(ref->label); + free(ref->url); + free(ref->title); + free(ref); + } +} + +// normalize reference: collapse internal whitespace to single space, +// remove leading/trailing whitespace, case fold +// Return NULL if the reference name is actually empty (i.e. composed +// solely from whitespace) +static unsigned char *normalize_reference(cmark_chunk *ref) +{ + cmark_strbuf normalized = GH_BUF_INIT; + unsigned char *result; + + if(ref == NULL) + return NULL; + + if (ref->len == 0) + return NULL; + + utf8proc_case_fold(&normalized, ref->data, ref->len); + cmark_strbuf_trim(&normalized); + cmark_strbuf_normalize_whitespace(&normalized); + + result = cmark_strbuf_detach(&normalized); + assert(result); + + if (result[0] == '\0') { + free(result); + return NULL; + } + + return result; +} + +static void add_reference(cmark_reference_map *map, cmark_reference* ref) +{ + cmark_reference *t = ref->next = map->table[ref->hash % REFMAP_SIZE]; + + while (t) { + if (t->hash == ref->hash && + !strcmp((char *)t->label, (char *)ref->label)) { + reference_free(ref); + return; + } + + t = t->next; + } + + map->table[ref->hash % REFMAP_SIZE] = ref; +} + +void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, + cmark_chunk *title) +{ + cmark_reference *ref; + unsigned char *reflabel = normalize_reference(label); + + /* empty reference name, or composed from only whitespace */ + if (reflabel == NULL) + return; + + ref = (cmark_reference *)calloc(1, sizeof(*ref)); + if(ref != NULL) { + ref->label = reflabel; + ref->hash = refhash(ref->label); + ref->url = cmark_clean_url(url); + ref->title = cmark_clean_title(title); + ref->next = NULL; + + add_reference(map, ref); + } +} + +// Returns reference if refmap contains a reference with matching +// label, otherwise NULL. +cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label) +{ + cmark_reference *ref = NULL; + unsigned char *norm; + unsigned int hash; + + if (label->len > MAX_LINK_LABEL_LENGTH) + return NULL; + + if (map == NULL) + return NULL; + + norm = normalize_reference(label); + if (norm == NULL) + return NULL; + + hash = refhash(norm); + ref = map->table[hash % REFMAP_SIZE]; + + while (ref) { + if (ref->hash == hash && + !strcmp((char *)ref->label, (char *)norm)) + break; + ref = ref->next; + } + + free(norm); + return ref; +} + +void cmark_reference_map_free(cmark_reference_map *map) +{ + unsigned int i; + + if(map == NULL) + return; + + for (i = 0; i < REFMAP_SIZE; ++i) { + cmark_reference *ref = map->table[i]; + cmark_reference *next; + + while (ref) { + next = ref->next; + reference_free(ref); + ref = next; + } + } + + free(map); +} + +cmark_reference_map *cmark_reference_map_new(void) +{ + return (cmark_reference_map *)calloc(1, sizeof(cmark_reference_map)); +} diff --git a/cmark/references.h b/cmark/references.h new file mode 100644 --- /dev/null +++ b/cmark/references.h @@ -0,0 +1,37 @@ +#ifndef CMARK_REFERENCES_H +#define CMARK_REFERENCES_H + +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define REFMAP_SIZE 16 + +struct cmark_reference { + struct cmark_reference *next; + unsigned char *label; + unsigned char *url; + unsigned char *title; + unsigned int hash; +}; + +typedef struct cmark_reference cmark_reference; + +struct cmark_reference_map { + cmark_reference *table[REFMAP_SIZE]; +}; + +typedef struct cmark_reference_map cmark_reference_map; + +cmark_reference_map *cmark_reference_map_new(void); +void cmark_reference_map_free(cmark_reference_map *map); +cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label); +extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, cmark_chunk *title); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/scanners.c b/cmark/scanners.c new file mode 100644 --- /dev/null +++ b/cmark/scanners.c @@ -0,0 +1,12392 @@ +/* Generated by re2c 0.13.6 */ +#include +#include "chunk.h" +#include "scanners.h" + +int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset) +{ + int res; + unsigned char *ptr = (unsigned char *)c->data; + unsigned char lim = ptr[c->len]; + + ptr[c->len] = '\0'; + res = scanner(ptr + offset); + ptr[c->len] = lim; + + return res; +} + + + +// Try to match URI autolink after first <, returning number of chars matched. +int _scan_autolink_uri(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 0, 128, 0, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + }; + + yych = *p; + switch (yych) { + case '\n': goto yy2; + case 'A': + case 'a': goto yy6; + case 'B': + case 'b': goto yy24; + case 'C': + case 'c': goto yy3; + case 'D': + case 'd': goto yy4; + case 'E': + case 'e': goto yy25; + case 'F': + case 'f': goto yy7; + case 'G': + case 'g': goto yy8; + case 'H': + case 'h': goto yy9; + case 'I': + case 'i': goto yy10; + case 'J': + case 'j': goto yy5; + case 'K': + case 'k': goto yy26; + case 'L': + case 'l': goto yy11; + case 'M': + case 'm': goto yy12; + case 'N': + case 'n': goto yy13; + case 'O': + case 'o': goto yy14; + case 'P': + case 'p': goto yy15; + case 'Q': + case 'q': goto yy27; + case 'R': + case 'r': goto yy16; + case 'S': + case 's': goto yy17; + case 'T': + case 't': goto yy18; + case 'U': + case 'u': goto yy19; + case 'V': + case 'v': goto yy20; + case 'W': + case 'w': goto yy21; + case 'X': + case 'x': goto yy22; + case 'Y': + case 'y': goto yy28; + case 'Z': + case 'z': goto yy23; + default: goto yy29; + } +yy2: + { return 0; } +yy3: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy442; + case 'H': + case 'h': goto yy441; + case 'I': + case 'i': goto yy444; + case 'O': + case 'o': goto yy440; + case 'R': + case 'r': goto yy443; + case 'V': + case 'v': goto yy439; + default: goto yy2; + } +yy4: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy415; + case 'I': + case 'i': goto yy414; + case 'L': + case 'l': goto yy412; + case 'N': + case 'n': goto yy413; + case 'O': + case 'o': goto yy416; + case 'T': + case 't': goto yy411; + case 'V': + case 'v': goto yy410; + default: goto yy2; + } +yy5: + yych = *(marker = ++p); + if (yych <= 'M') { + if (yych == 'A') goto yy402; + if (yych <= 'L') goto yy2; + goto yy401; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy2; + goto yy402; + } else { + if (yych == 'm') goto yy401; + goto yy2; + } + } +yy6: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy383; + case 'B': + case 'b': goto yy382; + case 'C': + case 'c': goto yy381; + case 'D': + case 'd': goto yy380; + case 'F': + case 'f': goto yy379; + case 'I': + case 'i': goto yy378; + case 'P': + case 'p': goto yy377; + case 'T': + case 't': goto yy376; + case 'W': + case 'w': goto yy34; + default: goto yy2; + } +yy7: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'E') { + if (yych == 'A') goto yy363; + if (yych <= 'D') goto yy2; + goto yy362; + } else { + if (yych == 'I') goto yy361; + if (yych <= 'S') goto yy2; + goto yy364; + } + } else { + if (yych <= 'e') { + if (yych == 'a') goto yy363; + if (yych <= 'd') goto yy2; + goto yy362; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy2; + goto yy361; + } else { + if (yych == 't') goto yy364; + goto yy2; + } + } + } +yy8: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy346; + case 'G': + case 'g': goto yy34; + case 'I': + case 'i': goto yy344; + case 'O': + case 'o': goto yy345; + case 'T': + case 't': goto yy343; + default: goto yy2; + } +yy9: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= '3') { + if (yych <= '2') goto yy2; + goto yy339; + } else { + if (yych == 'C') goto yy337; + goto yy2; + } + } else { + if (yych <= 'c') { + if (yych <= 'T') goto yy338; + if (yych <= 'b') goto yy2; + goto yy337; + } else { + if (yych == 't') goto yy338; + goto yy2; + } + } +yy10: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy319; + case 'C': + case 'c': goto yy316; + case 'M': + case 'm': goto yy318; + case 'N': + case 'n': goto yy317; + case 'P': + case 'p': goto yy315; + case 'R': + case 'r': goto yy314; + case 'T': + case 't': goto yy313; + default: goto yy2; + } +yy11: + yych = *(marker = ++p); + if (yych <= 'D') { + if (yych == 'A') goto yy307; + if (yych <= 'C') goto yy2; + goto yy306; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy2; + goto yy307; + } else { + if (yych == 'd') goto yy306; + goto yy2; + } + } +yy12: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy273; + case 'E': + case 'e': goto yy272; + case 'I': + case 'i': goto yy275; + case 'M': + case 'm': goto yy271; + case 'S': + case 's': goto yy270; + case 'T': + case 't': goto yy274; + case 'U': + case 'u': goto yy269; + case 'V': + case 'v': goto yy268; + default: goto yy2; + } +yy13: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy263; + case 'F': + case 'f': goto yy262; + case 'I': + case 'i': goto yy261; + case 'N': + case 'n': goto yy260; + case 'O': + case 'o': goto yy259; + default: goto yy2; + } +yy14: + yych = *(marker = ++p); + if (yych <= 'P') { + if (yych == 'I') goto yy245; + if (yych <= 'O') goto yy2; + goto yy246; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy2; + goto yy245; + } else { + if (yych == 'p') goto yy246; + goto yy2; + } + } +yy15: + yych = *(marker = ++p); + if (yych <= 'S') { + if (yych <= 'L') { + if (yych == 'A') goto yy227; + if (yych <= 'K') goto yy2; + goto yy226; + } else { + if (yych <= 'O') { + if (yych <= 'N') goto yy2; + goto yy228; + } else { + if (yych <= 'Q') goto yy2; + if (yych <= 'R') goto yy225; + goto yy224; + } + } + } else { + if (yych <= 'n') { + if (yych <= 'a') { + if (yych <= '`') goto yy2; + goto yy227; + } else { + if (yych == 'l') goto yy226; + goto yy2; + } + } else { + if (yych <= 'q') { + if (yych <= 'o') goto yy228; + goto yy2; + } else { + if (yych <= 'r') goto yy225; + if (yych <= 's') goto yy224; + goto yy2; + } + } + } +yy16: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'L') { + if (yych == 'E') goto yy214; + goto yy2; + } else { + if (yych <= 'M') goto yy213; + if (yych <= 'R') goto yy2; + if (yych <= 'S') goto yy212; + goto yy211; + } + } else { + if (yych <= 'm') { + if (yych == 'e') goto yy214; + if (yych <= 'l') goto yy2; + goto yy213; + } else { + if (yych <= 'r') goto yy2; + if (yych <= 's') goto yy212; + if (yych <= 't') goto yy211; + goto yy2; + } + } +yy17: + yych = *(marker = ++p); + switch (yych) { + case 'E': + case 'e': goto yy167; + case 'F': + case 'f': goto yy166; + case 'G': + case 'g': goto yy165; + case 'H': + case 'h': goto yy170; + case 'I': + case 'i': goto yy169; + case 'K': + case 'k': goto yy164; + case 'M': + case 'm': goto yy163; + case 'N': + case 'n': goto yy168; + case 'O': + case 'o': goto yy162; + case 'P': + case 'p': goto yy161; + case 'S': + case 's': goto yy160; + case 'T': + case 't': goto yy159; + case 'V': + case 'v': goto yy158; + default: goto yy2; + } +yy18: + yych = *(marker = ++p); + switch (yych) { + case 'A': + case 'a': goto yy134; + case 'E': + case 'e': goto yy130; + case 'F': + case 'f': goto yy133; + case 'H': + case 'h': goto yy129; + case 'I': + case 'i': goto yy131; + case 'N': + case 'n': goto yy132; + case 'V': + case 'v': goto yy34; + default: goto yy2; + } +yy19: + yych = *(marker = ++p); + if (yych <= 'T') { + if (yych <= 'N') { + if (yych == 'D') goto yy121; + if (yych <= 'M') goto yy2; + goto yy120; + } else { + if (yych == 'R') goto yy122; + if (yych <= 'S') goto yy2; + goto yy119; + } + } else { + if (yych <= 'n') { + if (yych == 'd') goto yy121; + if (yych <= 'm') goto yy2; + goto yy120; + } else { + if (yych <= 'r') { + if (yych <= 'q') goto yy2; + goto yy122; + } else { + if (yych == 't') goto yy119; + goto yy2; + } + } + } +yy20: + yych = *(marker = ++p); + if (yych <= 'I') { + if (yych == 'E') goto yy103; + if (yych <= 'H') goto yy2; + goto yy102; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy2; + goto yy103; + } else { + if (yych == 'i') goto yy102; + goto yy2; + } + } +yy21: + yych = *(marker = ++p); + if (yych <= 'Y') { + if (yych <= 'R') { + if (yych == 'E') goto yy92; + goto yy2; + } else { + if (yych <= 'S') goto yy93; + if (yych <= 'T') goto yy91; + if (yych <= 'X') goto yy2; + goto yy90; + } + } else { + if (yych <= 's') { + if (yych == 'e') goto yy92; + if (yych <= 'r') goto yy2; + goto yy93; + } else { + if (yych <= 't') goto yy91; + if (yych == 'y') goto yy90; + goto yy2; + } + } +yy22: + yych = *(marker = ++p); + if (yych <= 'R') { + if (yych <= 'F') { + if (yych == 'C') goto yy69; + if (yych <= 'E') goto yy2; + goto yy67; + } else { + if (yych == 'M') goto yy68; + if (yych <= 'Q') goto yy2; + goto yy66; + } + } else { + if (yych <= 'f') { + if (yych == 'c') goto yy69; + if (yych <= 'e') goto yy2; + goto yy67; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy2; + goto yy68; + } else { + if (yych == 'r') goto yy66; + goto yy2; + } + } + } +yy23: + yych = *(marker = ++p); + if (yych == '3') goto yy61; + goto yy2; +yy24: + yych = *(marker = ++p); + if (yych <= 'O') { + if (yych <= 'H') { + if (yych == 'E') goto yy51; + goto yy2; + } else { + if (yych <= 'I') goto yy50; + if (yych <= 'N') goto yy2; + goto yy49; + } + } else { + if (yych <= 'h') { + if (yych == 'e') goto yy51; + goto yy2; + } else { + if (yych <= 'i') goto yy50; + if (yych == 'o') goto yy49; + goto yy2; + } + } +yy25: + yych = *(marker = ++p); + if (yych == 'D') goto yy47; + if (yych == 'd') goto yy47; + goto yy2; +yy26: + yych = *(marker = ++p); + if (yych == 'E') goto yy42; + if (yych == 'e') goto yy42; + goto yy2; +yy27: + yych = *(marker = ++p); + if (yych == 'U') goto yy39; + if (yych == 'u') goto yy39; + goto yy2; +yy28: + yych = *(marker = ++p); + if (yych == 'M') goto yy30; + if (yych == 'm') goto yy30; + goto yy2; +yy29: + yych = *++p; + goto yy2; +yy30: + yych = *++p; + if (yych == 'S') goto yy32; + if (yych == 's') goto yy32; +yy31: + p = marker; + goto yy2; +yy32: + yych = *++p; + if (yych == 'G') goto yy33; + if (yych != 'g') goto yy31; +yy33: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych != 'r') goto yy31; +yy34: + yych = *++p; + if (yych != ':') goto yy31; +yy35: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy35; + } + if (yych <= '=') goto yy31; + ++p; + { return (p - start); } +yy39: + yych = *++p; + if (yych == 'E') goto yy40; + if (yych != 'e') goto yy31; +yy40: + yych = *++p; + if (yych == 'R') goto yy41; + if (yych != 'r') goto yy31; +yy41: + yych = *++p; + if (yych == 'Y') goto yy34; + if (yych == 'y') goto yy34; + goto yy31; +yy42: + yych = *++p; + if (yych == 'Y') goto yy43; + if (yych != 'y') goto yy31; +yy43: + yych = *++p; + if (yych == 'P') goto yy44; + if (yych != 'p') goto yy31; +yy44: + yych = *++p; + if (yych == 'A') goto yy45; + if (yych != 'a') goto yy31; +yy45: + yych = *++p; + if (yych == 'R') goto yy46; + if (yych != 'r') goto yy31; +yy46: + yych = *++p; + if (yych == 'C') goto yy34; + if (yych == 'c') goto yy34; + goto yy31; +yy47: + yych = *++p; + if (yych != '2') goto yy31; + yych = *++p; + if (yych == 'K') goto yy34; + if (yych == 'k') goto yy34; + goto yy31; +yy49: + yych = *++p; + if (yych == 'L') goto yy60; + if (yych == 'l') goto yy60; + goto yy31; +yy50: + yych = *++p; + if (yych == 'T') goto yy56; + if (yych == 't') goto yy56; + goto yy31; +yy51: + yych = *++p; + if (yych == 'S') goto yy52; + if (yych != 's') goto yy31; +yy52: + yych = *++p; + if (yych == 'H') goto yy53; + if (yych != 'h') goto yy31; +yy53: + yych = *++p; + if (yych == 'A') goto yy54; + if (yych != 'a') goto yy31; +yy54: + yych = *++p; + if (yych == 'R') goto yy55; + if (yych != 'r') goto yy31; +yy55: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy56: + yych = *++p; + if (yych == 'C') goto yy57; + if (yych != 'c') goto yy31; +yy57: + yych = *++p; + if (yych == 'O') goto yy58; + if (yych != 'o') goto yy31; +yy58: + yych = *++p; + if (yych == 'I') goto yy59; + if (yych != 'i') goto yy31; +yy59: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy60: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy61: + yych = *++p; + if (yych != '9') goto yy31; + yych = *++p; + if (yych != '.') goto yy31; + yych = *++p; + if (yych != '5') goto yy31; + yych = *++p; + if (yych != '0') goto yy31; + yych = *++p; + if (yych <= 'Q') goto yy31; + if (yych <= 'S') goto yy34; + if (yych <= 'q') goto yy31; + if (yych <= 's') goto yy34; + goto yy31; +yy66: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy67: + yych = *++p; + if (yych == 'I') goto yy88; + if (yych == 'i') goto yy88; + goto yy31; +yy68: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy78; + if (yych <= 'O') goto yy31; + goto yy79; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy31; + goto yy78; + } else { + if (yych == 'p') goto yy79; + goto yy31; + } + } +yy69: + yych = *++p; + if (yych == 'O') goto yy70; + if (yych != 'o') goto yy31; +yy70: + yych = *++p; + if (yych == 'N') goto yy71; + if (yych != 'n') goto yy31; +yy71: + yych = *++p; + if (yych == '-') goto yy72; + if (yych == ':') goto yy35; + goto yy31; +yy72: + yych = *++p; + if (yych == 'U') goto yy73; + if (yych != 'u') goto yy31; +yy73: + yych = *++p; + if (yych == 'S') goto yy74; + if (yych != 's') goto yy31; +yy74: + yych = *++p; + if (yych == 'E') goto yy75; + if (yych != 'e') goto yy31; +yy75: + yych = *++p; + if (yych == 'R') goto yy76; + if (yych != 'r') goto yy31; +yy76: + yych = *++p; + if (yych == 'I') goto yy77; + if (yych != 'i') goto yy31; +yy77: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy78: + yych = *++p; + if (yych == 'R') goto yy80; + if (yych == 'r') goto yy80; + goto yy31; +yy79: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy80: + yych = *++p; + if (yych == 'P') goto yy81; + if (yych != 'p') goto yy31; +yy81: + yych = *++p; + if (yych == 'C') goto yy82; + if (yych != 'c') goto yy31; +yy82: + yych = *++p; + if (yych != '.') goto yy31; + yych = *++p; + if (yych == 'B') goto yy84; + if (yych != 'b') goto yy31; +yy84: + yych = *++p; + if (yych == 'E') goto yy85; + if (yych != 'e') goto yy31; +yy85: + yych = *++p; + if (yych == 'E') goto yy86; + if (yych != 'e') goto yy31; +yy86: + yych = *++p; + if (yych == 'P') goto yy87; + if (yych != 'p') goto yy31; +yy87: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy88: + yych = *++p; + if (yych == 'R') goto yy89; + if (yych != 'r') goto yy31; +yy89: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy90: + yych = *++p; + if (yych == 'C') goto yy98; + if (yych == 'c') goto yy98; + goto yy31; +yy91: + yych = *++p; + if (yych == 'A') goto yy97; + if (yych == 'a') goto yy97; + goto yy31; +yy92: + yych = *++p; + if (yych == 'B') goto yy94; + if (yych == 'b') goto yy94; + goto yy31; +yy93: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy94: + yych = *++p; + if (yych == 'C') goto yy95; + if (yych != 'c') goto yy31; +yy95: + yych = *++p; + if (yych == 'A') goto yy96; + if (yych != 'a') goto yy31; +yy96: + yych = *++p; + if (yych == 'L') goto yy34; + if (yych == 'l') goto yy34; + goto yy31; +yy97: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy98: + yych = *++p; + if (yych == 'I') goto yy99; + if (yych != 'i') goto yy31; +yy99: + yych = *++p; + if (yych == 'W') goto yy100; + if (yych != 'w') goto yy31; +yy100: + yych = *++p; + if (yych == 'Y') goto yy101; + if (yych != 'y') goto yy31; +yy101: + yych = *++p; + if (yych == 'G') goto yy34; + if (yych == 'g') goto yy34; + goto yy31; +yy102: + yych = *++p; + if (yych == 'E') goto yy111; + if (yych == 'e') goto yy111; + goto yy31; +yy103: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'L') goto yy31; + if (yych >= 'N') goto yy105; + } else { + if (yych <= 'l') goto yy31; + if (yych <= 'm') goto yy104; + if (yych <= 'n') goto yy105; + goto yy31; + } +yy104: + yych = *++p; + if (yych == 'M') goto yy110; + if (yych == 'm') goto yy110; + goto yy31; +yy105: + yych = *++p; + if (yych == 'T') goto yy106; + if (yych != 't') goto yy31; +yy106: + yych = *++p; + if (yych == 'R') goto yy107; + if (yych != 'r') goto yy31; +yy107: + yych = *++p; + if (yych == 'I') goto yy108; + if (yych != 'i') goto yy31; +yy108: + yych = *++p; + if (yych == 'L') goto yy109; + if (yych != 'l') goto yy31; +yy109: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy110: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy111: + yych = *++p; + if (yych == 'W') goto yy112; + if (yych != 'w') goto yy31; +yy112: + yych = *++p; + if (yych != '-') goto yy31; + yych = *++p; + if (yych == 'S') goto yy114; + if (yych != 's') goto yy31; +yy114: + yych = *++p; + if (yych == 'O') goto yy115; + if (yych != 'o') goto yy31; +yy115: + yych = *++p; + if (yych == 'U') goto yy116; + if (yych != 'u') goto yy31; +yy116: + yych = *++p; + if (yych == 'R') goto yy117; + if (yych != 'r') goto yy31; +yy117: + yych = *++p; + if (yych == 'C') goto yy118; + if (yych != 'c') goto yy31; +yy118: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy119: + yych = *++p; + if (yych == '2') goto yy126; + goto yy31; +yy120: + yych = *++p; + if (yych == 'R') goto yy123; + if (yych == 'r') goto yy123; + goto yy31; +yy121: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy122: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy123: + yych = *++p; + if (yych == 'E') goto yy124; + if (yych != 'e') goto yy31; +yy124: + yych = *++p; + if (yych == 'A') goto yy125; + if (yych != 'a') goto yy31; +yy125: + yych = *++p; + if (yych == 'L') goto yy34; + if (yych == 'l') goto yy34; + goto yy31; +yy126: + yych = *++p; + if (yych != '0') goto yy31; + yych = *++p; + if (yych != '0') goto yy31; + yych = *++p; + if (yych == '4') goto yy34; + goto yy31; +yy129: + yych = *++p; + if (yych == 'I') goto yy148; + if (yych == 'i') goto yy148; + goto yy31; +yy130: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') goto yy140; + if (yych <= 'K') goto yy31; + goto yy139; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy31; + goto yy140; + } else { + if (yych == 'l') goto yy139; + goto yy31; + } + } +yy131: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy132: + yych = *++p; + if (yych == '3') goto yy136; + goto yy31; +yy133: + yych = *++p; + if (yych == 'T') goto yy135; + if (yych == 't') goto yy135; + goto yy31; +yy134: + yych = *++p; + if (yych == 'G') goto yy34; + if (yych == 'g') goto yy34; + goto yy31; +yy135: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy136: + yych = *++p; + if (yych != '2') goto yy31; + yych = *++p; + if (yych != '7') goto yy31; + yych = *++p; + if (yych == '0') goto yy34; + goto yy31; +yy139: + yych = *++p; + if (yych <= 'M') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'N') goto yy146; + if (yych == 'n') goto yy146; + goto yy31; + } +yy140: + yych = *++p; + if (yych == 'M') goto yy141; + if (yych != 'm') goto yy31; +yy141: + yych = *++p; + if (yych == 'S') goto yy142; + if (yych != 's') goto yy31; +yy142: + yych = *++p; + if (yych == 'P') goto yy143; + if (yych != 'p') goto yy31; +yy143: + yych = *++p; + if (yych == 'E') goto yy144; + if (yych != 'e') goto yy31; +yy144: + yych = *++p; + if (yych == 'A') goto yy145; + if (yych != 'a') goto yy31; +yy145: + yych = *++p; + if (yych == 'K') goto yy34; + if (yych == 'k') goto yy34; + goto yy31; +yy146: + yych = *++p; + if (yych == 'E') goto yy147; + if (yych != 'e') goto yy31; +yy147: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy148: + yych = *++p; + if (yych <= 'S') { + if (yych == 'N') goto yy149; + if (yych <= 'R') goto yy31; + goto yy150; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy31; + } else { + if (yych == 's') goto yy150; + goto yy31; + } + } +yy149: + yych = *++p; + if (yych == 'G') goto yy157; + if (yych == 'g') goto yy157; + goto yy31; +yy150: + yych = *++p; + if (yych == 'M') goto yy151; + if (yych != 'm') goto yy31; +yy151: + yych = *++p; + if (yych == 'E') goto yy152; + if (yych != 'e') goto yy31; +yy152: + yych = *++p; + if (yych == 'S') goto yy153; + if (yych != 's') goto yy31; +yy153: + yych = *++p; + if (yych == 'S') goto yy154; + if (yych != 's') goto yy31; +yy154: + yych = *++p; + if (yych == 'A') goto yy155; + if (yych != 'a') goto yy31; +yy155: + yych = *++p; + if (yych == 'G') goto yy156; + if (yych != 'g') goto yy31; +yy156: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy157: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy158: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy159: + yych = *++p; + if (yych == 'E') goto yy209; + if (yych == 'e') goto yy209; + goto yy31; +yy160: + yych = *++p; + if (yych == 'H') goto yy34; + if (yych == 'h') goto yy34; + goto yy31; +yy161: + yych = *++p; + if (yych == 'O') goto yy205; + if (yych == 'o') goto yy205; + goto yy31; +yy162: + yych = *++p; + if (yych <= 'L') { + if (yych == 'A') goto yy195; + if (yych <= 'K') goto yy31; + goto yy196; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy31; + goto yy195; + } else { + if (yych == 'l') goto yy196; + goto yy31; + } + } +yy163: + yych = *++p; + if (yych <= 'S') { + if (yych == 'B') goto yy34; + if (yych <= 'R') goto yy31; + goto yy34; + } else { + if (yych <= 'b') { + if (yych <= 'a') goto yy31; + goto yy34; + } else { + if (yych == 's') goto yy34; + goto yy31; + } + } +yy164: + yych = *++p; + if (yych == 'Y') goto yy193; + if (yych == 'y') goto yy193; + goto yy31; +yy165: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy166: + yych = *++p; + if (yych == 'T') goto yy192; + if (yych == 't') goto yy192; + goto yy31; +yy167: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'C') { + if (yych <= 'B') goto yy31; + goto yy179; + } else { + if (yych <= 'Q') goto yy31; + if (yych <= 'R') goto yy177; + goto yy178; + } + } else { + if (yych <= 'q') { + if (yych == 'c') goto yy179; + goto yy31; + } else { + if (yych <= 'r') goto yy177; + if (yych <= 's') goto yy178; + goto yy31; + } + } +yy168: + yych = *++p; + if (yych == 'M') goto yy176; + if (yych == 'm') goto yy176; + goto yy31; +yy169: + yych = *++p; + if (yych <= 'P') { + if (yych == 'E') goto yy173; + if (yych <= 'O') goto yy31; + goto yy174; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy31; + goto yy173; + } else { + if (yych == 'p') goto yy174; + goto yy31; + } + } +yy170: + yych = *++p; + if (yych == 'T') goto yy171; + if (yych != 't') goto yy31; +yy171: + yych = *++p; + if (yych == 'T') goto yy172; + if (yych != 't') goto yy31; +yy172: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy173: + yych = *++p; + if (yych == 'V') goto yy175; + if (yych == 'v') goto yy175; + goto yy31; +yy174: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy175: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy176: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy177: + yych = *++p; + if (yych == 'V') goto yy189; + if (yych == 'v') goto yy189; + goto yy31; +yy178: + yych = *++p; + if (yych == 'S') goto yy186; + if (yych == 's') goto yy186; + goto yy31; +yy179: + yych = *++p; + if (yych == 'O') goto yy180; + if (yych != 'o') goto yy31; +yy180: + yych = *++p; + if (yych == 'N') goto yy181; + if (yych != 'n') goto yy31; +yy181: + yych = *++p; + if (yych == 'D') goto yy182; + if (yych != 'd') goto yy31; +yy182: + yych = *++p; + if (yych == 'L') goto yy183; + if (yych != 'l') goto yy31; +yy183: + yych = *++p; + if (yych == 'I') goto yy184; + if (yych != 'i') goto yy31; +yy184: + yych = *++p; + if (yych == 'F') goto yy185; + if (yych != 'f') goto yy31; +yy185: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy186: + yych = *++p; + if (yych == 'I') goto yy187; + if (yych != 'i') goto yy31; +yy187: + yych = *++p; + if (yych == 'O') goto yy188; + if (yych != 'o') goto yy31; +yy188: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy189: + yych = *++p; + if (yych == 'I') goto yy190; + if (yych != 'i') goto yy31; +yy190: + yych = *++p; + if (yych == 'C') goto yy191; + if (yych != 'c') goto yy31; +yy191: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy192: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy193: + yych = *++p; + if (yych == 'P') goto yy194; + if (yych != 'p') goto yy31; +yy194: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy195: + yych = *++p; + if (yych == 'P') goto yy199; + if (yych == 'p') goto yy199; + goto yy31; +yy196: + yych = *++p; + if (yych == 'D') goto yy197; + if (yych != 'd') goto yy31; +yy197: + yych = *++p; + if (yych == 'A') goto yy198; + if (yych != 'a') goto yy31; +yy198: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy199: + yych = *++p; + if (yych != '.') goto yy31; + yych = *++p; + if (yych == 'B') goto yy201; + if (yych != 'b') goto yy31; +yy201: + yych = *++p; + if (yych == 'E') goto yy202; + if (yych != 'e') goto yy31; +yy202: + yych = *++p; + if (yych == 'E') goto yy203; + if (yych != 'e') goto yy31; +yy203: + yych = *++p; + if (yych == 'P') goto yy204; + if (yych != 'p') goto yy31; +yy204: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy205: + yych = *++p; + if (yych == 'T') goto yy206; + if (yych != 't') goto yy31; +yy206: + yych = *++p; + if (yych == 'I') goto yy207; + if (yych != 'i') goto yy31; +yy207: + yych = *++p; + if (yych == 'F') goto yy208; + if (yych != 'f') goto yy31; +yy208: + yych = *++p; + if (yych == 'Y') goto yy34; + if (yych == 'y') goto yy34; + goto yy31; +yy209: + yych = *++p; + if (yych == 'A') goto yy210; + if (yych != 'a') goto yy31; +yy210: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy211: + yych = *++p; + if (yych <= 'S') { + if (yych == 'M') goto yy223; + if (yych <= 'R') goto yy31; + goto yy222; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy31; + goto yy223; + } else { + if (yych == 's') goto yy222; + goto yy31; + } + } +yy212: + yych = *++p; + if (yych == 'Y') goto yy220; + if (yych == 'y') goto yy220; + goto yy31; +yy213: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy214: + yych = *++p; + if (yych == 'S') goto yy215; + if (yych != 's') goto yy31; +yy215: + yych = *++p; + if (yych <= 'N') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'O') goto yy216; + if (yych != 'o') goto yy31; + } +yy216: + yych = *++p; + if (yych == 'U') goto yy217; + if (yych != 'u') goto yy31; +yy217: + yych = *++p; + if (yych == 'R') goto yy218; + if (yych != 'r') goto yy31; +yy218: + yych = *++p; + if (yych == 'C') goto yy219; + if (yych != 'c') goto yy31; +yy219: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy220: + yych = *++p; + if (yych == 'N') goto yy221; + if (yych != 'n') goto yy31; +yy221: + yych = *++p; + if (yych == 'C') goto yy34; + if (yych == 'c') goto yy34; + goto yy31; +yy222: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy223: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy224: + yych = *++p; + if (yych == 'Y') goto yy244; + if (yych == 'y') goto yy244; + goto yy31; +yy225: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') goto yy241; + if (yych <= 'N') goto yy31; + goto yy242; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy31; + goto yy241; + } else { + if (yych == 'o') goto yy242; + goto yy31; + } + } +yy226: + yych = *++p; + if (yych == 'A') goto yy236; + if (yych == 'a') goto yy236; + goto yy31; +yy227: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy229; + if (yych <= 'O') goto yy31; + goto yy230; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy31; + goto yy229; + } else { + if (yych == 'p') goto yy230; + goto yy31; + } + } +yy228: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy229: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy230: + yych = *++p; + if (yych == 'A') goto yy231; + if (yych != 'a') goto yy31; +yy231: + yych = *++p; + if (yych == 'R') goto yy232; + if (yych != 'r') goto yy31; +yy232: + yych = *++p; + if (yych == 'A') goto yy233; + if (yych != 'a') goto yy31; +yy233: + yych = *++p; + if (yych == 'Z') goto yy234; + if (yych != 'z') goto yy31; +yy234: + yych = *++p; + if (yych == 'Z') goto yy235; + if (yych != 'z') goto yy31; +yy235: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy236: + yych = *++p; + if (yych == 'T') goto yy237; + if (yych != 't') goto yy31; +yy237: + yych = *++p; + if (yych == 'F') goto yy238; + if (yych != 'f') goto yy31; +yy238: + yych = *++p; + if (yych == 'O') goto yy239; + if (yych != 'o') goto yy31; +yy239: + yych = *++p; + if (yych == 'R') goto yy240; + if (yych != 'r') goto yy31; +yy240: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy241: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy242: + yych = *++p; + if (yych == 'X') goto yy243; + if (yych != 'x') goto yy31; +yy243: + yych = *++p; + if (yych == 'Y') goto yy34; + if (yych == 'y') goto yy34; + goto yy31; +yy244: + yych = *++p; + if (yych == 'C') goto yy34; + if (yych == 'c') goto yy34; + goto yy31; +yy245: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy246: + yych = *++p; + if (yych == 'A') goto yy247; + if (yych != 'a') goto yy31; +yy247: + yych = *++p; + if (yych == 'Q') goto yy248; + if (yych != 'q') goto yy31; +yy248: + yych = *++p; + if (yych == 'U') goto yy249; + if (yych != 'u') goto yy31; +yy249: + yych = *++p; + if (yych == 'E') goto yy250; + if (yych != 'e') goto yy31; +yy250: + yych = *++p; + if (yych == 'L') goto yy251; + if (yych != 'l') goto yy31; +yy251: + yych = *++p; + if (yych == 'O') goto yy252; + if (yych != 'o') goto yy31; +yy252: + yych = *++p; + if (yych == 'C') goto yy253; + if (yych != 'c') goto yy31; +yy253: + yych = *++p; + if (yych == 'K') goto yy254; + if (yych != 'k') goto yy31; +yy254: + yych = *++p; + if (yych == 'T') goto yy255; + if (yych != 't') goto yy31; +yy255: + yych = *++p; + if (yych == 'O') goto yy256; + if (yych != 'o') goto yy31; +yy256: + yych = *++p; + if (yych == 'K') goto yy257; + if (yych != 'k') goto yy31; +yy257: + yych = *++p; + if (yych == 'E') goto yy258; + if (yych != 'e') goto yy31; +yy258: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy259: + yych = *++p; + if (yych == 'T') goto yy266; + if (yych == 't') goto yy266; + goto yy31; +yy260: + yych = *++p; + if (yych == 'T') goto yy265; + if (yych == 't') goto yy265; + goto yy31; +yy261: + yych = *++p; + if (yych <= 'G') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'H') goto yy34; + if (yych == 'h') goto yy34; + goto yy31; + } +yy262: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy263: + yych = *++p; + if (yych == 'W') goto yy264; + if (yych != 'w') goto yy31; +yy264: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy265: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy266: + yych = *++p; + if (yych == 'E') goto yy267; + if (yych != 'e') goto yy31; +yy267: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy268: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy269: + yych = *++p; + if (yych <= 'P') { + if (yych == 'M') goto yy300; + if (yych <= 'O') goto yy31; + goto yy299; + } else { + if (yych <= 'm') { + if (yych <= 'l') goto yy31; + goto yy300; + } else { + if (yych == 'p') goto yy299; + goto yy31; + } + } +yy270: + yych = *++p; + if (yych <= 'Q') { + if (yych <= '-') { + if (yych <= ',') goto yy31; + goto yy292; + } else { + if (yych == 'N') goto yy293; + goto yy31; + } + } else { + if (yych <= 'n') { + if (yych <= 'R') goto yy291; + if (yych <= 'm') goto yy31; + goto yy293; + } else { + if (yych == 'r') goto yy291; + goto yy31; + } + } +yy271: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy272: + yych = *++p; + if (yych == 'S') goto yy287; + if (yych == 's') goto yy287; + goto yy31; +yy273: + yych = *++p; + switch (yych) { + case 'G': + case 'g': goto yy278; + case 'I': + case 'i': goto yy277; + case 'P': + case 'p': goto yy279; + case 'R': + case 'r': goto yy280; + default: goto yy31; + } +yy274: + yych = *++p; + if (yych == 'Q') goto yy276; + if (yych == 'q') goto yy276; + goto yy31; +yy275: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy276: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy277: + yych = *++p; + if (yych == 'L') goto yy285; + if (yych == 'l') goto yy285; + goto yy31; +yy278: + yych = *++p; + if (yych == 'N') goto yy283; + if (yych == 'n') goto yy283; + goto yy31; +yy279: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy280: + yych = *++p; + if (yych == 'K') goto yy281; + if (yych != 'k') goto yy31; +yy281: + yych = *++p; + if (yych == 'E') goto yy282; + if (yych != 'e') goto yy31; +yy282: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy283: + yych = *++p; + if (yych == 'E') goto yy284; + if (yych != 'e') goto yy31; +yy284: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy285: + yych = *++p; + if (yych == 'T') goto yy286; + if (yych != 't') goto yy31; +yy286: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy287: + yych = *++p; + if (yych == 'S') goto yy288; + if (yych != 's') goto yy31; +yy288: + yych = *++p; + if (yych == 'A') goto yy289; + if (yych != 'a') goto yy31; +yy289: + yych = *++p; + if (yych == 'G') goto yy290; + if (yych != 'g') goto yy31; +yy290: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy291: + yych = *++p; + if (yych == 'P') goto yy298; + if (yych == 'p') goto yy298; + goto yy31; +yy292: + yych = *++p; + if (yych == 'H') goto yy295; + if (yych == 'h') goto yy295; + goto yy31; +yy293: + yych = *++p; + if (yych == 'I') goto yy294; + if (yych != 'i') goto yy31; +yy294: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy295: + yych = *++p; + if (yych == 'E') goto yy296; + if (yych != 'e') goto yy31; +yy296: + yych = *++p; + if (yych == 'L') goto yy297; + if (yych != 'l') goto yy31; +yy297: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy298: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy299: + yych = *++p; + if (yych == 'D') goto yy303; + if (yych == 'd') goto yy303; + goto yy31; +yy300: + yych = *++p; + if (yych == 'B') goto yy301; + if (yych != 'b') goto yy31; +yy301: + yych = *++p; + if (yych == 'L') goto yy302; + if (yych != 'l') goto yy31; +yy302: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy303: + yych = *++p; + if (yych == 'A') goto yy304; + if (yych != 'a') goto yy31; +yy304: + yych = *++p; + if (yych == 'T') goto yy305; + if (yych != 't') goto yy31; +yy305: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy306: + yych = *++p; + if (yych == 'A') goto yy311; + if (yych == 'a') goto yy311; + goto yy31; +yy307: + yych = *++p; + if (yych == 'S') goto yy308; + if (yych != 's') goto yy31; +yy308: + yych = *++p; + if (yych == 'T') goto yy309; + if (yych != 't') goto yy31; +yy309: + yych = *++p; + if (yych == 'F') goto yy310; + if (yych != 'f') goto yy31; +yy310: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy311: + yych = *++p; + if (yych == 'P') goto yy312; + if (yych != 'p') goto yy31; +yy312: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy313: + yych = *++p; + if (yych == 'M') goto yy336; + if (yych == 'm') goto yy336; + goto yy31; +yy314: + yych = *++p; + if (yych <= 'I') { + if (yych == 'C') goto yy325; + if (yych <= 'H') goto yy31; + goto yy324; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy31; + goto yy325; + } else { + if (yych == 'i') goto yy324; + goto yy31; + } + } +yy315: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy34; + if (yych <= 'O') goto yy31; + goto yy34; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy31; + goto yy34; + } else { + if (yych == 'p') goto yy34; + goto yy31; + } + } +yy316: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') goto yy322; + if (yych <= 'N') goto yy31; + goto yy323; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy31; + goto yy322; + } else { + if (yych == 'o') goto yy323; + goto yy31; + } + } +yy317: + yych = *++p; + if (yych == 'F') goto yy321; + if (yych == 'f') goto yy321; + goto yy31; +yy318: + yych = *++p; + if (yych <= '@') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'A') goto yy320; + if (yych == 'a') goto yy320; + goto yy31; + } +yy319: + yych = *++p; + if (yych == 'X') goto yy34; + if (yych == 'x') goto yy34; + goto yy31; +yy320: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy321: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy322: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy323: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy324: + yych = *++p; + if (yych == 'S') goto yy326; + if (yych == 's') goto yy326; + goto yy31; +yy325: + yych = *++p; + if (yych <= ':') { + if (yych == '6') goto yy34; + if (yych <= '9') goto yy31; + goto yy35; + } else { + if (yych <= 'S') { + if (yych <= 'R') goto yy31; + goto yy34; + } else { + if (yych == 's') goto yy34; + goto yy31; + } + } +yy326: + yych = *++p; + if (yych == '.') goto yy327; + if (yych == ':') goto yy35; + goto yy31; +yy327: + yych = *++p; + if (yych <= 'X') { + if (yych <= 'K') { + if (yych == 'B') goto yy330; + goto yy31; + } else { + if (yych <= 'L') goto yy328; + if (yych <= 'W') goto yy31; + goto yy329; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy330; + goto yy31; + } else { + if (yych <= 'l') goto yy328; + if (yych == 'x') goto yy329; + goto yy31; + } + } +yy328: + yych = *++p; + if (yych == 'W') goto yy335; + if (yych == 'w') goto yy335; + goto yy31; +yy329: + yych = *++p; + if (yych == 'P') goto yy333; + if (yych == 'p') goto yy333; + goto yy31; +yy330: + yych = *++p; + if (yych == 'E') goto yy331; + if (yych != 'e') goto yy31; +yy331: + yych = *++p; + if (yych == 'E') goto yy332; + if (yych != 'e') goto yy31; +yy332: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy333: + yych = *++p; + if (yych == 'C') goto yy334; + if (yych != 'c') goto yy31; +yy334: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy335: + yych = *++p; + if (yych == 'Z') goto yy34; + if (yych == 'z') goto yy34; + goto yy31; +yy336: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy337: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy338: + yych = *++p; + if (yych == 'T') goto yy341; + if (yych == 't') goto yy341; + goto yy31; +yy339: + yych = *++p; + if (yych != '2') goto yy31; + yych = *++p; + if (yych == '3') goto yy34; + goto yy31; +yy341: + yych = *++p; + if (yych == 'P') goto yy342; + if (yych != 'p') goto yy31; +yy342: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy343: + yych = *++p; + if (yych == 'A') goto yy359; + if (yych == 'a') goto yy359; + goto yy31; +yy344: + yych = *++p; + if (yych <= 'Z') { + if (yych == 'T') goto yy34; + if (yych <= 'Y') goto yy31; + goto yy350; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy31; + goto yy34; + } else { + if (yych == 'z') goto yy350; + goto yy31; + } + } +yy345: + yych = *++p; + if (yych <= 'O') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'P') goto yy347; + if (yych == 'p') goto yy347; + goto yy31; + } +yy346: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy347: + yych = *++p; + if (yych == 'H') goto yy348; + if (yych != 'h') goto yy31; +yy348: + yych = *++p; + if (yych == 'E') goto yy349; + if (yych != 'e') goto yy31; +yy349: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych == 'r') goto yy34; + goto yy31; +yy350: + yych = *++p; + if (yych == 'M') goto yy351; + if (yych != 'm') goto yy31; +yy351: + yych = *++p; + if (yych == 'O') goto yy352; + if (yych != 'o') goto yy31; +yy352: + yych = *++p; + if (yych == 'P') goto yy353; + if (yych != 'p') goto yy31; +yy353: + yych = *++p; + if (yych == 'R') goto yy354; + if (yych != 'r') goto yy31; +yy354: + yych = *++p; + if (yych == 'O') goto yy355; + if (yych != 'o') goto yy31; +yy355: + yych = *++p; + if (yych == 'J') goto yy356; + if (yych != 'j') goto yy31; +yy356: + yych = *++p; + if (yych == 'E') goto yy357; + if (yych != 'e') goto yy31; +yy357: + yych = *++p; + if (yych == 'C') goto yy358; + if (yych != 'c') goto yy31; +yy358: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy359: + yych = *++p; + if (yych == 'L') goto yy360; + if (yych != 'l') goto yy31; +yy360: + yych = *++p; + if (yych == 'K') goto yy34; + if (yych == 'k') goto yy34; + goto yy31; +yy361: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'M') { + if (yych == 'L') goto yy371; + goto yy31; + } else { + if (yych <= 'N') goto yy372; + if (yych <= 'R') goto yy31; + goto yy373; + } + } else { + if (yych <= 'm') { + if (yych == 'l') goto yy371; + goto yy31; + } else { + if (yych <= 'n') goto yy372; + if (yych == 's') goto yy373; + goto yy31; + } + } +yy362: + yych = *++p; + if (yych == 'E') goto yy370; + if (yych == 'e') goto yy370; + goto yy31; +yy363: + yych = *++p; + if (yych == 'C') goto yy365; + if (yych == 'c') goto yy365; + goto yy31; +yy364: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy365: + yych = *++p; + if (yych == 'E') goto yy366; + if (yych != 'e') goto yy31; +yy366: + yych = *++p; + if (yych == 'T') goto yy367; + if (yych != 't') goto yy31; +yy367: + yych = *++p; + if (yych == 'I') goto yy368; + if (yych != 'i') goto yy31; +yy368: + yych = *++p; + if (yych == 'M') goto yy369; + if (yych != 'm') goto yy31; +yy369: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy370: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy371: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy372: + yych = *++p; + if (yych == 'G') goto yy374; + if (yych == 'g') goto yy374; + goto yy31; +yy373: + yych = *++p; + if (yych == 'H') goto yy34; + if (yych == 'h') goto yy34; + goto yy31; +yy374: + yych = *++p; + if (yych == 'E') goto yy375; + if (yych != 'e') goto yy31; +yy375: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych == 'r') goto yy34; + goto yy31; +yy376: + yych = *++p; + if (yych == 'T') goto yy394; + if (yych == 't') goto yy394; + goto yy31; +yy377: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy378: + yych = *++p; + if (yych == 'M') goto yy34; + if (yych == 'm') goto yy34; + goto yy31; +yy379: + yych = *++p; + if (yych <= 'S') { + if (yych == 'P') goto yy34; + if (yych <= 'R') goto yy31; + goto yy34; + } else { + if (yych <= 'p') { + if (yych <= 'o') goto yy31; + goto yy34; + } else { + if (yych == 's') goto yy34; + goto yy31; + } + } +yy380: + yych = *++p; + if (yych == 'I') goto yy388; + if (yych == 'i') goto yy388; + goto yy31; +yy381: + yych = *++p; + if (yych == 'A') goto yy387; + if (yych == 'a') goto yy387; + goto yy31; +yy382: + yych = *++p; + if (yych == 'O') goto yy385; + if (yych == 'o') goto yy385; + goto yy31; +yy383: + yych = *++p; + if (yych == 'A') goto yy384; + if (yych != 'a') goto yy31; +yy384: + yych = *++p; + if (yych <= 'R') { + if (yych == ':') goto yy35; + goto yy31; + } else { + if (yych <= 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; + } +yy385: + yych = *++p; + if (yych == 'U') goto yy386; + if (yych != 'u') goto yy31; +yy386: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy387: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy388: + yych = *++p; + if (yych == 'U') goto yy389; + if (yych != 'u') goto yy31; +yy389: + yych = *++p; + if (yych == 'M') goto yy390; + if (yych != 'm') goto yy31; +yy390: + yych = *++p; + if (yych == 'X') goto yy391; + if (yych != 'x') goto yy31; +yy391: + yych = *++p; + if (yych == 'T') goto yy392; + if (yych != 't') goto yy31; +yy392: + yych = *++p; + if (yych == 'R') goto yy393; + if (yych != 'r') goto yy31; +yy393: + yych = *++p; + if (yych == 'A') goto yy34; + if (yych == 'a') goto yy34; + goto yy31; +yy394: + yych = *++p; + if (yych == 'A') goto yy395; + if (yych != 'a') goto yy31; +yy395: + yych = *++p; + if (yych == 'C') goto yy396; + if (yych != 'c') goto yy31; +yy396: + yych = *++p; + if (yych == 'H') goto yy397; + if (yych != 'h') goto yy31; +yy397: + yych = *++p; + if (yych == 'M') goto yy398; + if (yych != 'm') goto yy31; +yy398: + yych = *++p; + if (yych == 'E') goto yy399; + if (yych != 'e') goto yy31; +yy399: + yych = *++p; + if (yych == 'N') goto yy400; + if (yych != 'n') goto yy31; +yy400: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy401: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy402: + yych = *++p; + if (yych <= 'V') { + if (yych == 'R') goto yy34; + if (yych <= 'U') goto yy31; + } else { + if (yych <= 'r') { + if (yych <= 'q') goto yy31; + goto yy34; + } else { + if (yych != 'v') goto yy31; + } + } + yych = *++p; + if (yych == 'A') goto yy404; + if (yych != 'a') goto yy31; +yy404: + yych = *++p; + if (yych == 'S') goto yy405; + if (yych != 's') goto yy31; +yy405: + yych = *++p; + if (yych == 'C') goto yy406; + if (yych != 'c') goto yy31; +yy406: + yych = *++p; + if (yych == 'R') goto yy407; + if (yych != 'r') goto yy31; +yy407: + yych = *++p; + if (yych == 'I') goto yy408; + if (yych != 'i') goto yy31; +yy408: + yych = *++p; + if (yych == 'P') goto yy409; + if (yych != 'p') goto yy31; +yy409: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy410: + yych = *++p; + if (yych == 'B') goto yy34; + if (yych == 'b') goto yy34; + goto yy31; +yy411: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy412: + yych = *++p; + if (yych == 'N') goto yy419; + if (yych == 'n') goto yy419; + goto yy31; +yy413: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy414: + yych = *++p; + if (yych == 'C') goto yy418; + if (yych == 'c') goto yy418; + goto yy31; +yy415: + yych = *++p; + if (yych <= 'V') { + if (yych == 'T') goto yy417; + if (yych <= 'U') goto yy31; + goto yy34; + } else { + if (yych <= 't') { + if (yych <= 's') goto yy31; + goto yy417; + } else { + if (yych == 'v') goto yy34; + goto yy31; + } + } +yy416: + yych = *++p; + if (yych == 'I') goto yy34; + if (yych == 'i') goto yy34; + goto yy31; +yy417: + yych = *++p; + if (yych == 'A') goto yy34; + if (yych == 'a') goto yy34; + goto yy31; +yy418: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy419: + yych = *++p; + if (yych == 'A') goto yy420; + if (yych != 'a') goto yy31; +yy420: + yych = *++p; + if (yych != '-') goto yy31; + yych = *++p; + if (yych == 'P') goto yy422; + if (yych != 'p') goto yy31; +yy422: + yych = *++p; + if (yych == 'L') goto yy423; + if (yych != 'l') goto yy31; +yy423: + yych = *++p; + if (yych == 'A') goto yy424; + if (yych != 'a') goto yy31; +yy424: + yych = *++p; + if (yych == 'Y') goto yy425; + if (yych != 'y') goto yy31; +yy425: + yych = *++p; + if (yych <= 'S') { + if (yych == 'C') goto yy426; + if (yych <= 'R') goto yy31; + goto yy427; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy31; + } else { + if (yych == 's') goto yy427; + goto yy31; + } + } +yy426: + yych = *++p; + if (yych == 'O') goto yy432; + if (yych == 'o') goto yy432; + goto yy31; +yy427: + yych = *++p; + if (yych == 'I') goto yy428; + if (yych != 'i') goto yy31; +yy428: + yych = *++p; + if (yych == 'N') goto yy429; + if (yych != 'n') goto yy31; +yy429: + yych = *++p; + if (yych == 'G') goto yy430; + if (yych != 'g') goto yy31; +yy430: + yych = *++p; + if (yych == 'L') goto yy431; + if (yych != 'l') goto yy31; +yy431: + yych = *++p; + if (yych == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +yy432: + yych = *++p; + if (yych == 'N') goto yy433; + if (yych != 'n') goto yy31; +yy433: + yych = *++p; + if (yych == 'T') goto yy434; + if (yych != 't') goto yy31; +yy434: + yych = *++p; + if (yych == 'A') goto yy435; + if (yych != 'a') goto yy31; +yy435: + yych = *++p; + if (yych == 'I') goto yy436; + if (yych != 'i') goto yy31; +yy436: + yych = *++p; + if (yych == 'N') goto yy437; + if (yych != 'n') goto yy31; +yy437: + yych = *++p; + if (yych == 'E') goto yy438; + if (yych != 'e') goto yy31; +yy438: + yych = *++p; + if (yych == 'R') goto yy34; + if (yych == 'r') goto yy34; + goto yy31; +yy439: + yych = *++p; + if (yych == 'S') goto yy34; + if (yych == 's') goto yy34; + goto yy31; +yy440: + yych = *++p; + if (yych <= 'N') { + if (yych <= 'A') { + if (yych <= '@') goto yy31; + goto yy462; + } else { + if (yych <= 'L') goto yy31; + if (yych <= 'M') goto yy463; + goto yy464; + } + } else { + if (yych <= 'l') { + if (yych == 'a') goto yy462; + goto yy31; + } else { + if (yych <= 'm') goto yy463; + if (yych <= 'n') goto yy464; + goto yy31; + } + } +yy441: + yych = *++p; + if (yych == 'R') goto yy449; + if (yych == 'r') goto yy449; + goto yy31; +yy442: + yych = *++p; + if (yych <= 'P') { + if (yych == 'L') goto yy446; + if (yych <= 'O') goto yy31; + goto yy34; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy31; + goto yy446; + } else { + if (yych == 'p') goto yy34; + goto yy31; + } + } +yy443: + yych = *++p; + if (yych == 'I') goto yy445; + if (yych == 'i') goto yy445; + goto yy31; +yy444: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy445: + yych = *++p; + if (yych == 'D') goto yy34; + if (yych == 'd') goto yy34; + goto yy31; +yy446: + yych = *++p; + if (yych == 'L') goto yy447; + if (yych != 'l') goto yy31; +yy447: + yych = *++p; + if (yych == 'T') goto yy448; + if (yych != 't') goto yy31; +yy448: + yych = *++p; + if (yych == 'O') goto yy34; + if (yych == 'o') goto yy34; + goto yy31; +yy449: + yych = *++p; + if (yych == 'O') goto yy450; + if (yych != 'o') goto yy31; +yy450: + yych = *++p; + if (yych == 'M') goto yy451; + if (yych != 'm') goto yy31; +yy451: + yych = *++p; + if (yych == 'E') goto yy452; + if (yych != 'e') goto yy31; +yy452: + yych = *++p; + if (yych == '-') goto yy453; + if (yych == ':') goto yy35; + goto yy31; +yy453: + yych = *++p; + if (yych == 'E') goto yy454; + if (yych != 'e') goto yy31; +yy454: + yych = *++p; + if (yych == 'X') goto yy455; + if (yych != 'x') goto yy31; +yy455: + yych = *++p; + if (yych == 'T') goto yy456; + if (yych != 't') goto yy31; +yy456: + yych = *++p; + if (yych == 'E') goto yy457; + if (yych != 'e') goto yy31; +yy457: + yych = *++p; + if (yych == 'N') goto yy458; + if (yych != 'n') goto yy31; +yy458: + yych = *++p; + if (yych == 'S') goto yy459; + if (yych != 's') goto yy31; +yy459: + yych = *++p; + if (yych == 'I') goto yy460; + if (yych != 'i') goto yy31; +yy460: + yych = *++p; + if (yych == 'O') goto yy461; + if (yych != 'o') goto yy31; +yy461: + yych = *++p; + if (yych == 'N') goto yy34; + if (yych == 'n') goto yy34; + goto yy31; +yy462: + yych = *++p; + if (yych == 'P') goto yy34; + if (yych == 'p') goto yy34; + goto yy31; +yy463: + yych = *++p; + if (yych == '-') goto yy468; + goto yy31; +yy464: + yych = *++p; + if (yych == 'T') goto yy465; + if (yych != 't') goto yy31; +yy465: + yych = *++p; + if (yych == 'E') goto yy466; + if (yych != 'e') goto yy31; +yy466: + yych = *++p; + if (yych == 'N') goto yy467; + if (yych != 'n') goto yy31; +yy467: + yych = *++p; + if (yych == 'T') goto yy34; + if (yych == 't') goto yy34; + goto yy31; +yy468: + yych = *++p; + if (yych == 'E') goto yy469; + if (yych != 'e') goto yy31; +yy469: + yych = *++p; + if (yych == 'V') goto yy470; + if (yych != 'v') goto yy31; +yy470: + yych = *++p; + if (yych == 'E') goto yy471; + if (yych != 'e') goto yy31; +yy471: + yych = *++p; + if (yych == 'N') goto yy472; + if (yych != 'n') goto yy31; +yy472: + yych = *++p; + if (yych == 'T') goto yy473; + if (yych != 't') goto yy31; +yy473: + yych = *++p; + if (yych == 'B') goto yy474; + if (yych != 'b') goto yy31; +yy474: + yych = *++p; + if (yych == 'R') goto yy475; + if (yych != 'r') goto yy31; +yy475: + yych = *++p; + if (yych == 'I') goto yy476; + if (yych != 'i') goto yy31; +yy476: + yych = *++p; + if (yych == 'T') goto yy477; + if (yych != 't') goto yy31; +yy477: + yych = *++p; + if (yych == 'E') goto yy478; + if (yych != 'e') goto yy31; +yy478: + yych = *++p; + if (yych != '-') goto yy31; + yych = *++p; + if (yych == 'A') goto yy480; + if (yych != 'a') goto yy31; +yy480: + yych = *++p; + if (yych == 'T') goto yy481; + if (yych != 't') goto yy31; +yy481: + yych = *++p; + if (yych == 'T') goto yy482; + if (yych != 't') goto yy31; +yy482: + yych = *++p; + if (yych == 'E') goto yy483; + if (yych != 'e') goto yy31; +yy483: + yych = *++p; + if (yych == 'N') goto yy484; + if (yych != 'n') goto yy31; +yy484: + yych = *++p; + if (yych == 'D') goto yy485; + if (yych != 'd') goto yy31; +yy485: + yych = *++p; + if (yych == 'E') goto yy486; + if (yych != 'e') goto yy31; +yy486: + ++p; + if ((yych = *p) == 'E') goto yy34; + if (yych == 'e') goto yy34; + goto yy31; +} + +} + +// Try to match email autolink after first <, returning num of chars matched. +int _scan_autolink_email(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 0, 128, 128, 128, 128, 128, + 0, 0, 128, 128, 0, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 0, 0, 0, 128, 0, 128, + 0, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 0, 0, 0, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 128, + 128, 128, 128, 128, 128, 128, 128, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= ',') { + if (yych <= '!') { + if (yych == '\n') goto yy489; + if (yych <= ' ') goto yy491; + goto yy490; + } else { + if (yych <= '\'') { + if (yych <= '"') goto yy491; + goto yy490; + } else { + if (yych <= ')') goto yy491; + if (yych <= '+') goto yy490; + goto yy491; + } + } + } else { + if (yych <= '?') { + if (yych <= '<') { + if (yych <= '9') goto yy490; + goto yy491; + } else { + if (yych == '>') goto yy491; + goto yy490; + } + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy491; + goto yy490; + } else { + if (yych <= ']') goto yy491; + if (yych <= '~') goto yy490; + goto yy491; + } + } + } +yy489: + { return 0; } +yy490: + yych = *(marker = ++p); + if (yych <= ',') { + if (yych <= '"') { + if (yych == '!') goto yy495; + goto yy489; + } else { + if (yych <= '\'') goto yy495; + if (yych <= ')') goto yy489; + if (yych <= '+') goto yy495; + goto yy489; + } + } else { + if (yych <= '>') { + if (yych <= '9') goto yy495; + if (yych == '=') goto yy495; + goto yy489; + } else { + if (yych <= 'Z') goto yy495; + if (yych <= ']') goto yy489; + if (yych <= '~') goto yy495; + goto yy489; + } + } +yy491: + yych = *++p; + goto yy489; +yy492: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy496; + } else { + if (yych <= 'Z') goto yy496; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy496; + } +yy493: + p = marker; + goto yy489; +yy494: + ++p; + yych = *p; +yy495: + if (yybm[0+yych] & 128) { + goto yy494; + } + if (yych == '@') goto yy492; + goto yy493; +yy496: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy498; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy498; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy498; + goto yy493; + } + } + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy626; + if (yych <= '/') goto yy493; + goto yy627; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy627; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy627; + goto yy493; + } + } +yy498: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych <= '-') goto yy626; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy627; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy627; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy627; + goto yy493; + } + } +yy499: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy502; + goto yy493; + } else { + if (yych <= 'Z') goto yy502; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy502; + goto yy493; + } +yy500: + ++p; + { return (p - start); } +yy502: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy504; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy504; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy504; + goto yy493; + } + } + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy505; + if (yych <= '/') goto yy493; + goto yy506; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy506; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy506; + goto yy493; + } + } +yy504: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy506; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy506; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy506; + goto yy493; + } + } +yy505: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy507; + if (yych <= '/') goto yy493; + goto yy508; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy508; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy508; + goto yy493; + } + } +yy506: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy508; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy508; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy508; + goto yy493; + } + } +yy507: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy509; + if (yych <= '/') goto yy493; + goto yy510; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy510; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy510; + goto yy493; + } + } +yy508: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy510; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy510; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy510; + goto yy493; + } + } +yy509: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy511; + if (yych <= '/') goto yy493; + goto yy512; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy512; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy512; + goto yy493; + } + } +yy510: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy512; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy512; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy512; + goto yy493; + } + } +yy511: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy513; + if (yych <= '/') goto yy493; + goto yy514; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy514; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy514; + goto yy493; + } + } +yy512: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy514; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy514; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy514; + goto yy493; + } + } +yy513: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy515; + if (yych <= '/') goto yy493; + goto yy516; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy516; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy516; + goto yy493; + } + } +yy514: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy516; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy516; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy516; + goto yy493; + } + } +yy515: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy517; + if (yych <= '/') goto yy493; + goto yy518; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy518; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy518; + goto yy493; + } + } +yy516: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy518; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy518; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy518; + goto yy493; + } + } +yy517: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy519; + if (yych <= '/') goto yy493; + goto yy520; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy520; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy520; + goto yy493; + } + } +yy518: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy520; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy520; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy520; + goto yy493; + } + } +yy519: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy521; + if (yych <= '/') goto yy493; + goto yy522; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy522; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy522; + goto yy493; + } + } +yy520: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy522; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy522; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy522; + goto yy493; + } + } +yy521: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy523; + if (yych <= '/') goto yy493; + goto yy524; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy524; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy524; + goto yy493; + } + } +yy522: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy524; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy524; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy524; + goto yy493; + } + } +yy523: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy525; + if (yych <= '/') goto yy493; + goto yy526; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy526; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy526; + goto yy493; + } + } +yy524: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy526; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy526; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy526; + goto yy493; + } + } +yy525: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy527; + if (yych <= '/') goto yy493; + goto yy528; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy528; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy528; + goto yy493; + } + } +yy526: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy528; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy528; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy528; + goto yy493; + } + } +yy527: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy529; + if (yych <= '/') goto yy493; + goto yy530; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy530; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy530; + goto yy493; + } + } +yy528: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy530; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy530; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy530; + goto yy493; + } + } +yy529: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy531; + if (yych <= '/') goto yy493; + goto yy532; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy532; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy532; + goto yy493; + } + } +yy530: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy532; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy532; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy532; + goto yy493; + } + } +yy531: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy533; + if (yych <= '/') goto yy493; + goto yy534; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy534; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy534; + goto yy493; + } + } +yy532: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy534; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy534; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy534; + goto yy493; + } + } +yy533: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy535; + if (yych <= '/') goto yy493; + goto yy536; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy536; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy536; + goto yy493; + } + } +yy534: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy536; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy536; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy536; + goto yy493; + } + } +yy535: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy537; + if (yych <= '/') goto yy493; + goto yy538; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy538; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy538; + goto yy493; + } + } +yy536: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy538; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy538; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy538; + goto yy493; + } + } +yy537: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy539; + if (yych <= '/') goto yy493; + goto yy540; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy540; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy540; + goto yy493; + } + } +yy538: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy540; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy540; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy540; + goto yy493; + } + } +yy539: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy541; + if (yych <= '/') goto yy493; + goto yy542; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy542; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy542; + goto yy493; + } + } +yy540: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy542; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy542; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy542; + goto yy493; + } + } +yy541: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy543; + if (yych <= '/') goto yy493; + goto yy544; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy544; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy544; + goto yy493; + } + } +yy542: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy544; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy544; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy544; + goto yy493; + } + } +yy543: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy545; + if (yych <= '/') goto yy493; + goto yy546; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy546; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy546; + goto yy493; + } + } +yy544: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy546; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy546; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy546; + goto yy493; + } + } +yy545: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy547; + if (yych <= '/') goto yy493; + goto yy548; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy548; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy548; + goto yy493; + } + } +yy546: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy548; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy548; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy548; + goto yy493; + } + } +yy547: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy549; + if (yych <= '/') goto yy493; + goto yy550; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy550; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy550; + goto yy493; + } + } +yy548: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy550; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy550; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy550; + goto yy493; + } + } +yy549: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy551; + if (yych <= '/') goto yy493; + goto yy552; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy552; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy552; + goto yy493; + } + } +yy550: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy552; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy552; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy552; + goto yy493; + } + } +yy551: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy553; + if (yych <= '/') goto yy493; + goto yy554; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy554; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy554; + goto yy493; + } + } +yy552: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy554; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy554; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy554; + goto yy493; + } + } +yy553: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy555; + if (yych <= '/') goto yy493; + goto yy556; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy556; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy556; + goto yy493; + } + } +yy554: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy556; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy556; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy556; + goto yy493; + } + } +yy555: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy557; + if (yych <= '/') goto yy493; + goto yy558; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy558; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy558; + goto yy493; + } + } +yy556: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy558; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy558; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy558; + goto yy493; + } + } +yy557: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy559; + if (yych <= '/') goto yy493; + goto yy560; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy560; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy560; + goto yy493; + } + } +yy558: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy560; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy560; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy560; + goto yy493; + } + } +yy559: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy561; + if (yych <= '/') goto yy493; + goto yy562; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy562; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy562; + goto yy493; + } + } +yy560: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy562; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy562; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy562; + goto yy493; + } + } +yy561: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy563; + if (yych <= '/') goto yy493; + goto yy564; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy564; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy564; + goto yy493; + } + } +yy562: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy564; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy564; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy564; + goto yy493; + } + } +yy563: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy565; + if (yych <= '/') goto yy493; + goto yy566; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy566; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy566; + goto yy493; + } + } +yy564: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy566; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy566; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy566; + goto yy493; + } + } +yy565: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy567; + if (yych <= '/') goto yy493; + goto yy568; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy568; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy568; + goto yy493; + } + } +yy566: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy568; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy568; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy568; + goto yy493; + } + } +yy567: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy569; + if (yych <= '/') goto yy493; + goto yy570; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy570; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy570; + goto yy493; + } + } +yy568: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy570; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy570; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy570; + goto yy493; + } + } +yy569: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy571; + if (yych <= '/') goto yy493; + goto yy572; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy572; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy572; + goto yy493; + } + } +yy570: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy572; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy572; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy572; + goto yy493; + } + } +yy571: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy573; + if (yych <= '/') goto yy493; + goto yy574; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy574; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy574; + goto yy493; + } + } +yy572: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy574; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy574; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy574; + goto yy493; + } + } +yy573: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy575; + if (yych <= '/') goto yy493; + goto yy576; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy576; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy576; + goto yy493; + } + } +yy574: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy576; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy576; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy576; + goto yy493; + } + } +yy575: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy577; + if (yych <= '/') goto yy493; + goto yy578; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy578; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy578; + goto yy493; + } + } +yy576: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy578; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy578; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy578; + goto yy493; + } + } +yy577: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy579; + if (yych <= '/') goto yy493; + goto yy580; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy580; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy580; + goto yy493; + } + } +yy578: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy580; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy580; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy580; + goto yy493; + } + } +yy579: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy581; + if (yych <= '/') goto yy493; + goto yy582; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy582; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy582; + goto yy493; + } + } +yy580: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy582; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy582; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy582; + goto yy493; + } + } +yy581: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy583; + if (yych <= '/') goto yy493; + goto yy584; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy584; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy584; + goto yy493; + } + } +yy582: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy584; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy584; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy584; + goto yy493; + } + } +yy583: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy585; + if (yych <= '/') goto yy493; + goto yy586; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy586; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy586; + goto yy493; + } + } +yy584: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy586; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy586; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy586; + goto yy493; + } + } +yy585: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy587; + if (yych <= '/') goto yy493; + goto yy588; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy588; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy588; + goto yy493; + } + } +yy586: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy588; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy588; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy588; + goto yy493; + } + } +yy587: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy589; + if (yych <= '/') goto yy493; + goto yy590; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy590; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy590; + goto yy493; + } + } +yy588: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy590; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy590; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy590; + goto yy493; + } + } +yy589: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy591; + if (yych <= '/') goto yy493; + goto yy592; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy592; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy592; + goto yy493; + } + } +yy590: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy592; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy592; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy592; + goto yy493; + } + } +yy591: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy593; + if (yych <= '/') goto yy493; + goto yy594; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy594; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy594; + goto yy493; + } + } +yy592: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy594; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy594; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy594; + goto yy493; + } + } +yy593: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy595; + if (yych <= '/') goto yy493; + goto yy596; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy596; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy596; + goto yy493; + } + } +yy594: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy596; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy596; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy596; + goto yy493; + } + } +yy595: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy597; + if (yych <= '/') goto yy493; + goto yy598; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy598; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy598; + goto yy493; + } + } +yy596: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy598; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy598; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy598; + goto yy493; + } + } +yy597: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy599; + if (yych <= '/') goto yy493; + goto yy600; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy600; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy600; + goto yy493; + } + } +yy598: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy600; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy600; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy600; + goto yy493; + } + } +yy599: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy601; + if (yych <= '/') goto yy493; + goto yy602; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy602; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy602; + goto yy493; + } + } +yy600: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy602; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy602; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy602; + goto yy493; + } + } +yy601: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy603; + if (yych <= '/') goto yy493; + goto yy604; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy604; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy604; + goto yy493; + } + } +yy602: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy604; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy604; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy604; + goto yy493; + } + } +yy603: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy605; + if (yych <= '/') goto yy493; + goto yy606; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy606; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy606; + goto yy493; + } + } +yy604: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy606; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy606; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy606; + goto yy493; + } + } +yy605: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy607; + if (yych <= '/') goto yy493; + goto yy608; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy608; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy608; + goto yy493; + } + } +yy606: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy608; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy608; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy608; + goto yy493; + } + } +yy607: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy609; + if (yych <= '/') goto yy493; + goto yy610; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy610; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy610; + goto yy493; + } + } +yy608: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy610; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy610; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy610; + goto yy493; + } + } +yy609: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy611; + if (yych <= '/') goto yy493; + goto yy612; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy612; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy612; + goto yy493; + } + } +yy610: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy612; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy612; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy612; + goto yy493; + } + } +yy611: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy613; + if (yych <= '/') goto yy493; + goto yy614; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy614; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy614; + goto yy493; + } + } +yy612: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy614; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy614; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy614; + goto yy493; + } + } +yy613: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy615; + if (yych <= '/') goto yy493; + goto yy616; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy616; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy616; + goto yy493; + } + } +yy614: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy616; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy616; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy616; + goto yy493; + } + } +yy615: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy617; + if (yych <= '/') goto yy493; + goto yy618; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy618; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy618; + goto yy493; + } + } +yy616: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy618; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy618; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy618; + goto yy493; + } + } +yy617: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy619; + if (yych <= '/') goto yy493; + goto yy620; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy620; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy620; + goto yy493; + } + } +yy618: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy620; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy620; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy620; + goto yy493; + } + } +yy619: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy621; + if (yych <= '/') goto yy493; + goto yy622; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy622; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy622; + goto yy493; + } + } +yy620: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy622; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy622; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy622; + goto yy493; + } + } +yy621: + ++p; + yych = *p; + if (yych <= '9') { + if (yych == '-') goto yy623; + if (yych <= '/') goto yy493; + goto yy624; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy624; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy624; + goto yy493; + } + } +yy622: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy624; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy624; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy624; + goto yy493; + } + } +yy623: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy625; + goto yy493; + } else { + if (yych <= 'Z') goto yy625; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy625; + goto yy493; + } +yy624: + ++p; + yych = *p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= '-') goto yy493; + goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych >= ':') goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + } else { + if (yych <= '`') goto yy493; + if (yych >= '{') goto yy493; + } + } +yy625: + ++p; + yych = *p; + if (yych == '.') goto yy499; + if (yych == '>') goto yy500; + goto yy493; +yy626: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy628; + if (yych <= '/') goto yy493; + goto yy629; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy629; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy629; + goto yy493; + } + } +yy627: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy629; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy629; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy629; + goto yy493; + } + } +yy628: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy630; + if (yych <= '/') goto yy493; + goto yy631; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy631; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy631; + goto yy493; + } + } +yy629: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy631; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy631; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy631; + goto yy493; + } + } +yy630: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy632; + if (yych <= '/') goto yy493; + goto yy633; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy633; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy633; + goto yy493; + } + } +yy631: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy633; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy633; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy633; + goto yy493; + } + } +yy632: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy634; + if (yych <= '/') goto yy493; + goto yy635; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy635; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy635; + goto yy493; + } + } +yy633: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy635; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy635; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy635; + goto yy493; + } + } +yy634: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy636; + if (yych <= '/') goto yy493; + goto yy637; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy637; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy637; + goto yy493; + } + } +yy635: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy637; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy637; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy637; + goto yy493; + } + } +yy636: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy638; + if (yych <= '/') goto yy493; + goto yy639; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy639; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy639; + goto yy493; + } + } +yy637: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy639; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy639; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy639; + goto yy493; + } + } +yy638: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy640; + if (yych <= '/') goto yy493; + goto yy641; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy641; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy641; + goto yy493; + } + } +yy639: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy641; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy641; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy641; + goto yy493; + } + } +yy640: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy642; + if (yych <= '/') goto yy493; + goto yy643; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy643; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy643; + goto yy493; + } + } +yy641: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy643; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy643; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy643; + goto yy493; + } + } +yy642: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy644; + if (yych <= '/') goto yy493; + goto yy645; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy645; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy645; + goto yy493; + } + } +yy643: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy645; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy645; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy645; + goto yy493; + } + } +yy644: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy646; + if (yych <= '/') goto yy493; + goto yy647; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy647; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy647; + goto yy493; + } + } +yy645: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy647; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy647; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy647; + goto yy493; + } + } +yy646: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy648; + if (yych <= '/') goto yy493; + goto yy649; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy649; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy649; + goto yy493; + } + } +yy647: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy649; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy649; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy649; + goto yy493; + } + } +yy648: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy650; + if (yych <= '/') goto yy493; + goto yy651; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy651; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy651; + goto yy493; + } + } +yy649: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy651; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy651; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy651; + goto yy493; + } + } +yy650: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy652; + if (yych <= '/') goto yy493; + goto yy653; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy653; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy653; + goto yy493; + } + } +yy651: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy653; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy653; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy653; + goto yy493; + } + } +yy652: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy654; + if (yych <= '/') goto yy493; + goto yy655; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy655; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy655; + goto yy493; + } + } +yy653: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy655; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy655; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy655; + goto yy493; + } + } +yy654: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy656; + if (yych <= '/') goto yy493; + goto yy657; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy657; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy657; + goto yy493; + } + } +yy655: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy657; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy657; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy657; + goto yy493; + } + } +yy656: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy658; + if (yych <= '/') goto yy493; + goto yy659; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy659; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy659; + goto yy493; + } + } +yy657: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy659; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy659; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy659; + goto yy493; + } + } +yy658: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy660; + if (yych <= '/') goto yy493; + goto yy661; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy661; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy661; + goto yy493; + } + } +yy659: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy661; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy661; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy661; + goto yy493; + } + } +yy660: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy662; + if (yych <= '/') goto yy493; + goto yy663; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy663; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy663; + goto yy493; + } + } +yy661: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy663; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy663; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy663; + goto yy493; + } + } +yy662: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy664; + if (yych <= '/') goto yy493; + goto yy665; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy665; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy665; + goto yy493; + } + } +yy663: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy665; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy665; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy665; + goto yy493; + } + } +yy664: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy666; + if (yych <= '/') goto yy493; + goto yy667; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy667; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy667; + goto yy493; + } + } +yy665: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy667; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy667; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy667; + goto yy493; + } + } +yy666: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy668; + if (yych <= '/') goto yy493; + goto yy669; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy669; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy669; + goto yy493; + } + } +yy667: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy669; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy669; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy669; + goto yy493; + } + } +yy668: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy670; + if (yych <= '/') goto yy493; + goto yy671; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy671; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy671; + goto yy493; + } + } +yy669: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy671; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy671; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy671; + goto yy493; + } + } +yy670: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy672; + if (yych <= '/') goto yy493; + goto yy673; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy673; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy673; + goto yy493; + } + } +yy671: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy673; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy673; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy673; + goto yy493; + } + } +yy672: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy674; + if (yych <= '/') goto yy493; + goto yy675; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy675; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy675; + goto yy493; + } + } +yy673: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy675; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy675; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy675; + goto yy493; + } + } +yy674: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy676; + if (yych <= '/') goto yy493; + goto yy677; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy677; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy677; + goto yy493; + } + } +yy675: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy677; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy677; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy677; + goto yy493; + } + } +yy676: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy678; + if (yych <= '/') goto yy493; + goto yy679; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy679; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy679; + goto yy493; + } + } +yy677: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy679; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy679; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy679; + goto yy493; + } + } +yy678: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy680; + if (yych <= '/') goto yy493; + goto yy681; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy681; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy681; + goto yy493; + } + } +yy679: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy681; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy681; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy681; + goto yy493; + } + } +yy680: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy682; + if (yych <= '/') goto yy493; + goto yy683; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy683; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy683; + goto yy493; + } + } +yy681: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy683; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy683; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy683; + goto yy493; + } + } +yy682: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy684; + if (yych <= '/') goto yy493; + goto yy685; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy685; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy685; + goto yy493; + } + } +yy683: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy685; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy685; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy685; + goto yy493; + } + } +yy684: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy686; + if (yych <= '/') goto yy493; + goto yy687; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy687; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy687; + goto yy493; + } + } +yy685: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy687; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy687; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy687; + goto yy493; + } + } +yy686: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy688; + if (yych <= '/') goto yy493; + goto yy689; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy689; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy689; + goto yy493; + } + } +yy687: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy689; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy689; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy689; + goto yy493; + } + } +yy688: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy690; + if (yych <= '/') goto yy493; + goto yy691; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy691; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy691; + goto yy493; + } + } +yy689: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy691; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy691; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy691; + goto yy493; + } + } +yy690: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy692; + if (yych <= '/') goto yy493; + goto yy693; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy693; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy693; + goto yy493; + } + } +yy691: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy693; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy693; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy693; + goto yy493; + } + } +yy692: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy694; + if (yych <= '/') goto yy493; + goto yy695; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy695; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy695; + goto yy493; + } + } +yy693: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy695; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy695; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy695; + goto yy493; + } + } +yy694: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy696; + if (yych <= '/') goto yy493; + goto yy697; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy697; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy697; + goto yy493; + } + } +yy695: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy697; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy697; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy697; + goto yy493; + } + } +yy696: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy698; + if (yych <= '/') goto yy493; + goto yy699; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy699; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy699; + goto yy493; + } + } +yy697: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy699; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy699; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy699; + goto yy493; + } + } +yy698: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy700; + if (yych <= '/') goto yy493; + goto yy701; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy701; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy701; + goto yy493; + } + } +yy699: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy701; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy701; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy701; + goto yy493; + } + } +yy700: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy702; + if (yych <= '/') goto yy493; + goto yy703; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy703; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy703; + goto yy493; + } + } +yy701: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy703; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy703; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy703; + goto yy493; + } + } +yy702: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy704; + if (yych <= '/') goto yy493; + goto yy705; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy705; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy705; + goto yy493; + } + } +yy703: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy705; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy705; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy705; + goto yy493; + } + } +yy704: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy706; + if (yych <= '/') goto yy493; + goto yy707; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy707; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy707; + goto yy493; + } + } +yy705: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy707; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy707; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy707; + goto yy493; + } + } +yy706: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy708; + if (yych <= '/') goto yy493; + goto yy709; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy709; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy709; + goto yy493; + } + } +yy707: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy709; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy709; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy709; + goto yy493; + } + } +yy708: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy710; + if (yych <= '/') goto yy493; + goto yy711; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy711; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy711; + goto yy493; + } + } +yy709: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy711; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy711; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy711; + goto yy493; + } + } +yy710: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy712; + if (yych <= '/') goto yy493; + goto yy713; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy713; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy713; + goto yy493; + } + } +yy711: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy713; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy713; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy713; + goto yy493; + } + } +yy712: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy714; + if (yych <= '/') goto yy493; + goto yy715; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy715; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy715; + goto yy493; + } + } +yy713: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy715; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy715; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy715; + goto yy493; + } + } +yy714: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy716; + if (yych <= '/') goto yy493; + goto yy717; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy717; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy717; + goto yy493; + } + } +yy715: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy717; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy717; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy717; + goto yy493; + } + } +yy716: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy718; + if (yych <= '/') goto yy493; + goto yy719; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy719; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy719; + goto yy493; + } + } +yy717: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy719; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy719; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy719; + goto yy493; + } + } +yy718: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy720; + if (yych <= '/') goto yy493; + goto yy721; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy721; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy721; + goto yy493; + } + } +yy719: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy721; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy721; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy721; + goto yy493; + } + } +yy720: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy722; + if (yych <= '/') goto yy493; + goto yy723; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy723; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy723; + goto yy493; + } + } +yy721: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy723; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy723; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy723; + goto yy493; + } + } +yy722: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy724; + if (yych <= '/') goto yy493; + goto yy725; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy725; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy725; + goto yy493; + } + } +yy723: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy725; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy725; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy725; + goto yy493; + } + } +yy724: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy726; + if (yych <= '/') goto yy493; + goto yy727; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy727; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy727; + goto yy493; + } + } +yy725: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy727; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy727; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy727; + goto yy493; + } + } +yy726: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy728; + if (yych <= '/') goto yy493; + goto yy729; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy729; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy729; + goto yy493; + } + } +yy727: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy729; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy729; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy729; + goto yy493; + } + } +yy728: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy730; + if (yych <= '/') goto yy493; + goto yy731; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy731; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy731; + goto yy493; + } + } +yy729: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy731; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy731; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy731; + goto yy493; + } + } +yy730: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy732; + if (yych <= '/') goto yy493; + goto yy733; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy733; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy733; + goto yy493; + } + } +yy731: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy733; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy733; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy733; + goto yy493; + } + } +yy732: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy734; + if (yych <= '/') goto yy493; + goto yy735; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy735; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy735; + goto yy493; + } + } +yy733: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy735; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy735; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy735; + goto yy493; + } + } +yy734: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy736; + if (yych <= '/') goto yy493; + goto yy737; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy737; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy737; + goto yy493; + } + } +yy735: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy737; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy737; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy737; + goto yy493; + } + } +yy736: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy738; + if (yych <= '/') goto yy493; + goto yy739; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy739; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy739; + goto yy493; + } + } +yy737: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy739; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy739; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy739; + goto yy493; + } + } +yy738: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy740; + if (yych <= '/') goto yy493; + goto yy741; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy741; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy741; + goto yy493; + } + } +yy739: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy741; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy741; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy741; + goto yy493; + } + } +yy740: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy742; + if (yych <= '/') goto yy493; + goto yy743; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy743; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy743; + goto yy493; + } + } +yy741: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy743; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy743; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy743; + goto yy493; + } + } +yy742: + yych = *++p; + if (yych <= '9') { + if (yych == '-') goto yy744; + if (yych <= '/') goto yy493; + goto yy745; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy493; + goto yy745; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy745; + goto yy493; + } + } +yy743: + yych = *++p; + if (yych <= '=') { + if (yych <= '.') { + if (yych <= ',') goto yy493; + if (yych >= '.') goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy745; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy745; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy745; + goto yy493; + } + } +yy744: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy625; + goto yy493; + } else { + if (yych <= 'Z') goto yy625; + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy625; + goto yy493; + } +yy745: + ++p; + if ((yych = *p) <= '=') { + if (yych <= '.') { + if (yych <= '-') goto yy493; + goto yy499; + } else { + if (yych <= '/') goto yy493; + if (yych <= '9') goto yy625; + goto yy493; + } + } else { + if (yych <= 'Z') { + if (yych <= '>') goto yy500; + if (yych <= '@') goto yy493; + goto yy625; + } else { + if (yych <= '`') goto yy493; + if (yych <= 'z') goto yy625; + goto yy493; + } + } +} + +} + +// Try to match an HTML tag after first <, returning num of chars matched. +int _scan_html_tag(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + /* table 1 .. 8: 0 */ + 0, 230, 230, 230, 230, 230, 230, 230, + 230, 199, 199, 199, 199, 199, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 199, 230, 70, 230, 230, 230, 230, 134, + 230, 230, 230, 230, 230, 246, 246, 230, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 246, 230, 198, 198, 196, 230, + 230, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 230, 230, 226, 230, 246, + 198, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + 230, 230, 230, 230, 230, 230, 230, 230, + /* table 9 .. 11: 256 */ + 0, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 32, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 128, + 160, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 224, 224, 224, 224, 224, + 224, 224, 224, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + }; + yych = *p; + if (yych <= '/') { + if (yych <= ' ') { + if (yych != '\n') goto yy753; + } else { + if (yych <= '!') goto yy751; + if (yych <= '.') goto yy753; + goto yy750; + } + } else { + if (yych <= '@') { + if (yych == '?') goto yy752; + goto yy753; + } else { + if (yych <= 'Z') goto yy749; + if (yych <= '`') goto yy753; + if (yych <= 'z') goto yy749; + goto yy753; + } + } +yy748: + { return 0; } +yy749: + yych = *(marker = ++p); + if (yych <= '9') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy748; + if (yych <= '\r') goto yy790; + goto yy748; + } else { + if (yych <= ' ') goto yy790; + if (yych <= '.') goto yy748; + if (yych <= '/') goto yy792; + goto yy788; + } + } else { + if (yych <= '@') { + if (yych == '>') goto yy758; + goto yy748; + } else { + if (yych <= 'Z') goto yy788; + if (yych <= '`') goto yy748; + if (yych <= 'z') goto yy788; + goto yy748; + } + } +yy750: + yych = *(marker = ++p); + if (yych <= '@') goto yy748; + if (yych <= 'Z') goto yy784; + if (yych <= '`') goto yy748; + if (yych <= 'z') goto yy784; + goto yy748; +yy751: + yych = *(marker = ++p); + if (yybm[256+yych] & 64) { + goto yy761; + } + if (yych == '-') goto yy763; + if (yych == '[') goto yy760; + goto yy748; +yy752: + yych = *(marker = ++p); + if (yych <= 0x00) goto yy748; + goto yy755; +yy753: + yych = *++p; + goto yy748; +yy754: + ++p; + yych = *p; +yy755: + if (yybm[256+yych] & 32) { + goto yy754; + } + if (yych >= 0x01) goto yy757; +yy756: + p = marker; + goto yy748; +yy757: + ++p; + yych = *p; + if (yych <= 0x00) goto yy756; + if (yych != '>') goto yy754; +yy758: + ++p; + { return (p - start); } +yy760: + yych = *++p; + if (yych == 'C') goto yy775; + if (yych == 'c') goto yy775; + goto yy756; +yy761: + ++p; + yych = *p; + if (yybm[0+yych] & 1) { + goto yy771; + } + if (yych <= '@') goto yy756; + if (yych <= 'Z') goto yy761; + goto yy756; +yy763: + yych = *++p; + if (yych != '-') goto yy756; + yych = *++p; + if (yych == '-') goto yy765; + if (yych == '>') goto yy756; + goto yy767; +yy765: + yych = *++p; + if (yych == '-') goto yy770; + if (yych == '>') goto yy756; + goto yy767; +yy766: + ++p; + yych = *p; +yy767: + if (yybm[256+yych] & 128) { + goto yy766; + } + if (yych <= 0x00) goto yy756; + ++p; + yych = *p; + if (yybm[256+yych] & 128) { + goto yy766; + } + if (yych <= 0x00) goto yy756; + yych = *++p; + if (yych == '>') goto yy758; + goto yy756; +yy770: + yych = *++p; + if (yych == '>') goto yy758; + goto yy756; +yy771: + ++p; + yych = *p; + if (yybm[0+yych] & 1) { + goto yy771; + } + if (yych <= 0x00) goto yy756; + if (yych == '>') goto yy758; +yy773: + ++p; + yych = *p; + if (yybm[0+yych] & 2) { + goto yy773; + } + if (yych <= 0x00) goto yy756; + goto yy758; +yy775: + yych = *++p; + if (yych == 'D') goto yy776; + if (yych != 'd') goto yy756; +yy776: + yych = *++p; + if (yych == 'A') goto yy777; + if (yych != 'a') goto yy756; +yy777: + yych = *++p; + if (yych == 'T') goto yy778; + if (yych != 't') goto yy756; +yy778: + yych = *++p; + if (yych == 'A') goto yy779; + if (yych != 'a') goto yy756; +yy779: + yych = *++p; + if (yych != '[') goto yy756; +yy780: + ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy780; + } + if (yych <= 0x00) goto yy756; + ++p; + yych = *p; + if (yybm[0+yych] & 4) { + goto yy780; + } + if (yych <= 0x00) goto yy756; + ++p; + yych = *p; + if (yych <= 0x00) goto yy756; + if (yych == '>') goto yy758; + goto yy780; +yy784: + ++p; + yych = *p; + if (yybm[0+yych] & 8) { + goto yy784; + } + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy756; + if (yych >= 0x0E) goto yy756; + } else { + if (yych <= ' ') goto yy786; + if (yych == '>') goto yy758; + goto yy756; + } +yy786: + ++p; + yych = *p; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy786; + goto yy756; + } else { + if (yych <= ' ') goto yy786; + if (yych == '>') goto yy758; + goto yy756; + } +yy788: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy756; + if (yych >= 0x0E) goto yy756; + } else { + if (yych <= ' ') goto yy790; + if (yych <= '.') goto yy756; + if (yych <= '/') goto yy792; + goto yy788; + } + } else { + if (yych <= '@') { + if (yych == '>') goto yy758; + goto yy756; + } else { + if (yych <= 'Z') goto yy788; + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy788; + goto yy756; + } + } +yy790: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy790; + if (yych <= 0x1F) goto yy756; + goto yy790; + } else { + if (yych == '/') goto yy792; + if (yych <= '9') goto yy756; + goto yy793; + } + } else { + if (yych <= 'Z') { + if (yych == '>') goto yy758; + if (yych <= '@') goto yy756; + goto yy793; + } else { + if (yych <= '_') { + if (yych <= '^') goto yy756; + goto yy793; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy793; + goto yy756; + } + } + } +yy792: + yych = *++p; + if (yych == '>') goto yy758; + goto yy756; +yy793: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy793; + } + if (yych <= '.') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy756; + } else { + if (yych != ' ') goto yy756; + } + } else { + if (yych <= '<') { + if (yych <= '/') goto yy792; + goto yy756; + } else { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + goto yy756; + } + } +yy795: + ++p; + yych = *p; + if (yych <= '<') { + if (yych <= ' ') { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy795; + if (yych <= 0x1F) goto yy756; + goto yy795; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy756; + goto yy792; + } else { + if (yych == ':') goto yy793; + goto yy756; + } + } + } else { + if (yych <= 'Z') { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + if (yych <= '@') goto yy756; + goto yy793; + } else { + if (yych <= '_') { + if (yych <= '^') goto yy756; + goto yy793; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy793; + goto yy756; + } + } + } +yy797: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy799; + } + if (yych <= 0x00) goto yy756; + if (yych <= '!') goto yy798; + if (yych <= '"') goto yy803; + if (yych <= ';') goto yy801; + goto yy756; +yy798: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy799; + } + if (yych <= '"') { + if (yych <= 0x00) goto yy756; + if (yych <= '!') goto yy812; + goto yy803; + } else { + if (yych <= ';') goto yy801; + if (yych == '>') goto yy758; + goto yy756; + } +yy799: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy799; + } + if (yych <= 0x00) goto yy756; + if (yych <= '!') goto yy806; + if (yych == '>') goto yy758; + goto yy756; +yy801: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy801; + } + if (yych <= 0x00) goto yy756; + goto yy805; +yy803: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy803; + } + if (yych <= 0x00) goto yy756; +yy805: + ++p; + yych = *p; + if (yych <= ' ') { + if (yych <= 0x08) goto yy756; + if (yych <= '\r') goto yy790; + if (yych <= 0x1F) goto yy756; + goto yy790; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy756; + goto yy792; + } else { + if (yych == '>') goto yy758; + goto yy756; + } + } +yy806: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy756; + goto yy799; + } else { + if (yych <= '\r') goto yy806; + if (yych <= 0x1F) goto yy799; + goto yy806; + } + } else { + if (yych <= '"') { + if (yych <= '!') goto yy799; + goto yy756; + } else { + if (yych == '\'') goto yy756; + goto yy799; + } + } + } else { + if (yych <= '@') { + if (yych <= ';') { + if (yych >= ';') goto yy799; + } else { + if (yych <= '=') goto yy756; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + } else { + if (yych <= '`') goto yy756; + if (yych >= '{') goto yy799; + } + } + } +yy808: + ++p; + yych = *p; + if (yych <= '/') { + if (yych <= '!') { + if (yych <= '\r') { + if (yych <= 0x00) goto yy756; + if (yych <= 0x08) goto yy799; + } else { + if (yych != ' ') goto yy799; + } + } else { + if (yych <= '\'') { + if (yych <= '"') goto yy756; + if (yych <= '&') goto yy799; + goto yy756; + } else { + if (yych <= ',') goto yy799; + if (yych <= '.') goto yy808; + goto yy799; + } + } + } else { + if (yych <= '@') { + if (yych <= '<') { + if (yych <= ':') goto yy808; + if (yych <= ';') goto yy799; + goto yy756; + } else { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + goto yy808; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy808; + goto yy799; + } + } + } +yy810: + ++p; + yych = *p; + if (yych <= ':') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy756; + goto yy799; + } else { + if (yych <= '\r') goto yy810; + if (yych <= 0x1F) goto yy799; + goto yy810; + } + } else { + if (yych <= '&') { + if (yych == '"') goto yy756; + goto yy799; + } else { + if (yych <= '\'') goto yy756; + if (yych <= '9') goto yy799; + goto yy808; + } + } + } else { + if (yych <= '@') { + if (yych <= '<') { + if (yych <= ';') goto yy799; + goto yy756; + } else { + if (yych <= '=') goto yy797; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + goto yy808; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy808; + goto yy799; + } + } + } +yy812: + ++p; + yych = *p; + if (yych <= '9') { + if (yych <= ' ') { + if (yych <= 0x08) { + if (yych <= 0x00) goto yy756; + goto yy799; + } else { + if (yych <= '\r') goto yy812; + if (yych <= 0x1F) goto yy799; + goto yy812; + } + } else { + if (yych <= '"') { + if (yych <= '!') goto yy799; + goto yy803; + } else { + if (yych == '\'') goto yy801; + goto yy799; + } + } + } else { + if (yych <= '@') { + if (yych <= ';') { + if (yych <= ':') goto yy808; + goto yy799; + } else { + if (yych <= '=') goto yy756; + if (yych <= '>') goto yy758; + goto yy799; + } + } else { + if (yych <= '_') { + if (yych <= 'Z') goto yy808; + if (yych <= '^') goto yy799; + goto yy808; + } else { + if (yych <= '`') goto yy756; + if (yych <= 'z') goto yy808; + goto yy799; + } + } + } +} + +} + +// Try to match an HTML block tag including first <, +// returning num of chars matched. +int _scan_html_block_tag(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + yych = *p; + if (yych == '\n') goto yy816; + if (yych == '<') goto yy817; + goto yy818; +yy816: + { return 0; } +yy817: + yych = *(marker = ++p); + switch (yych) { + case '!': + case '?': goto yy819; + case '/': goto yy838; + case 'A': + case 'a': goto yy823; + case 'B': + case 'b': goto yy826; + case 'C': + case 'c': goto yy830; + case 'D': + case 'd': goto yy831; + case 'E': + case 'e': goto yy834; + case 'F': + case 'f': goto yy835; + case 'H': + case 'h': goto yy824; + case 'I': + case 'i': goto yy825; + case 'L': + case 'l': goto yy827; + case 'M': + case 'm': goto yy828; + case 'O': + case 'o': goto yy829; + case 'P': + case 'p': goto yy821; + case 'S': + case 's': goto yy832; + case 'T': + case 't': goto yy833; + case 'U': + case 'u': goto yy836; + case 'V': + case 'v': goto yy837; + default: goto yy816; + } +yy818: + yych = *++p; + goto yy816; +yy819: + ++p; + { return (p - start); } +yy821: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + } else { + if (yych <= ' ') goto yy982; + if (yych >= '/') goto yy982; + } + } else { + if (yych <= 'Q') { + if (yych == '>') goto yy982; + } else { + if (yych <= 'R') goto yy1095; + if (yych == 'r') goto yy1095; + } + } +yy822: + p = marker; + goto yy816; +yy823: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'Q') goto yy822; + if (yych <= 'R') goto yy1088; + goto yy1087; + } else { + if (yych <= 'q') goto yy822; + if (yych <= 'r') goto yy1088; + if (yych <= 's') goto yy1087; + goto yy822; + } +yy824: + yych = *++p; + if (yych <= 'Q') { + if (yych <= 'D') { + if (yych <= '0') goto yy822; + if (yych <= '6') goto yy981; + goto yy822; + } else { + if (yych <= 'E') goto yy1080; + if (yych == 'G') goto yy1079; + goto yy822; + } + } else { + if (yych <= 'f') { + if (yych <= 'R') goto yy981; + if (yych == 'e') goto yy1080; + goto yy822; + } else { + if (yych <= 'g') goto yy1079; + if (yych == 'r') goto yy981; + goto yy822; + } + } +yy825: + yych = *++p; + if (yych == 'F') goto yy1075; + if (yych == 'f') goto yy1075; + goto yy822; +yy826: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'L') goto yy1063; + goto yy822; + } else { + if (yych <= 'O') goto yy1062; + if (yych <= 'T') goto yy822; + goto yy1061; + } + } else { + if (yych <= 'n') { + if (yych == 'l') goto yy1063; + goto yy822; + } else { + if (yych <= 'o') goto yy1062; + if (yych == 'u') goto yy1061; + goto yy822; + } + } +yy827: + yych = *++p; + if (yych == 'I') goto yy981; + if (yych == 'i') goto yy981; + goto yy822; +yy828: + yych = *++p; + if (yych == 'A') goto yy1060; + if (yych == 'a') goto yy1060; + goto yy822; +yy829: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'K') { + if (yych == 'B') goto yy1053; + goto yy822; + } else { + if (yych <= 'L') goto yy981; + if (yych <= 'T') goto yy822; + goto yy1052; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy1053; + goto yy822; + } else { + if (yych <= 'l') goto yy981; + if (yych == 'u') goto yy1052; + goto yy822; + } + } +yy830: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') goto yy1039; + if (yych <= 'N') goto yy822; + goto yy1038; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy822; + goto yy1039; + } else { + if (yych == 'o') goto yy1038; + goto yy822; + } + } +yy831: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'I') { + if (yych == 'D') goto yy981; + if (yych <= 'H') goto yy822; + goto yy1037; + } else { + if (yych == 'L') goto yy981; + if (yych <= 'S') goto yy822; + goto yy981; + } + } else { + if (yych <= 'i') { + if (yych == 'd') goto yy981; + if (yych <= 'h') goto yy822; + goto yy1037; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy822; + goto yy981; + } else { + if (yych == 't') goto yy981; + goto yy822; + } + } + } +yy832: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == 'C') goto yy1026; + goto yy822; + } else { + if (yych <= 'E') goto yy1027; + if (yych <= 'S') goto yy822; + goto yy1025; + } + } else { + if (yych <= 'd') { + if (yych == 'c') goto yy1026; + goto yy822; + } else { + if (yych <= 'e') goto yy1027; + if (yych == 't') goto yy1025; + goto yy822; + } + } +yy833: + yych = *++p; + switch (yych) { + case 'A': + case 'a': goto yy1011; + case 'B': + case 'b': goto yy1010; + case 'D': + case 'R': + case 'd': + case 'r': goto yy981; + case 'E': + case 'e': goto yy1009; + case 'F': + case 'f': goto yy1008; + case 'H': + case 'h': goto yy1007; + default: goto yy822; + } +yy834: + yych = *++p; + if (yych == 'M') goto yy1004; + if (yych == 'm') goto yy1004; + goto yy822; +yy835: + yych = *++p; + if (yych <= 'O') { + if (yych == 'I') goto yy985; + if (yych <= 'N') goto yy822; + goto yy984; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy822; + goto yy985; + } else { + if (yych == 'o') goto yy984; + goto yy822; + } + } +yy836: + yych = *++p; + if (yych == 'L') goto yy981; + if (yych == 'l') goto yy981; + goto yy822; +yy837: + yych = *++p; + if (yych == 'I') goto yy978; + if (yych == 'i') goto yy978; + goto yy822; +yy838: + yych = *++p; + switch (yych) { + case 'A': + case 'a': goto yy840; + case 'B': + case 'b': goto yy843; + case 'C': + case 'c': goto yy847; + case 'D': + case 'd': goto yy848; + case 'E': + case 'e': goto yy851; + case 'F': + case 'f': goto yy852; + case 'H': + case 'h': goto yy841; + case 'I': + case 'i': goto yy842; + case 'L': + case 'l': goto yy844; + case 'M': + case 'm': goto yy845; + case 'O': + case 'o': goto yy846; + case 'P': + case 'p': goto yy839; + case 'S': + case 's': goto yy849; + case 'T': + case 't': goto yy850; + case 'U': + case 'u': goto yy853; + case 'V': + case 'v': goto yy854; + default: goto yy822; + } +yy839: + yych = *++p; + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy822; + goto yy859; + } else { + if (yych == ' ') goto yy859; + goto yy822; + } + } else { + if (yych <= 'R') { + if (yych <= '>') goto yy859; + if (yych <= 'Q') goto yy822; + goto yy972; + } else { + if (yych == 'r') goto yy972; + goto yy822; + } + } +yy840: + yych = *++p; + if (yych <= 'S') { + if (yych <= 'Q') goto yy822; + if (yych <= 'R') goto yy965; + goto yy964; + } else { + if (yych <= 'q') goto yy822; + if (yych <= 'r') goto yy965; + if (yych <= 's') goto yy964; + goto yy822; + } +yy841: + yych = *++p; + if (yych <= 'Q') { + if (yych <= 'D') { + if (yych <= '0') goto yy822; + if (yych <= '6') goto yy858; + goto yy822; + } else { + if (yych <= 'E') goto yy957; + if (yych == 'G') goto yy956; + goto yy822; + } + } else { + if (yych <= 'f') { + if (yych <= 'R') goto yy858; + if (yych == 'e') goto yy957; + goto yy822; + } else { + if (yych <= 'g') goto yy956; + if (yych == 'r') goto yy858; + goto yy822; + } + } +yy842: + yych = *++p; + if (yych == 'F') goto yy952; + if (yych == 'f') goto yy952; + goto yy822; +yy843: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'N') { + if (yych == 'L') goto yy940; + goto yy822; + } else { + if (yych <= 'O') goto yy939; + if (yych <= 'T') goto yy822; + goto yy938; + } + } else { + if (yych <= 'n') { + if (yych == 'l') goto yy940; + goto yy822; + } else { + if (yych <= 'o') goto yy939; + if (yych == 'u') goto yy938; + goto yy822; + } + } +yy844: + yych = *++p; + if (yych == 'I') goto yy858; + if (yych == 'i') goto yy858; + goto yy822; +yy845: + yych = *++p; + if (yych == 'A') goto yy937; + if (yych == 'a') goto yy937; + goto yy822; +yy846: + yych = *++p; + if (yych <= 'U') { + if (yych <= 'K') { + if (yych == 'B') goto yy930; + goto yy822; + } else { + if (yych <= 'L') goto yy858; + if (yych <= 'T') goto yy822; + goto yy929; + } + } else { + if (yych <= 'k') { + if (yych == 'b') goto yy930; + goto yy822; + } else { + if (yych <= 'l') goto yy858; + if (yych == 'u') goto yy929; + goto yy822; + } + } +yy847: + yych = *++p; + if (yych <= 'O') { + if (yych == 'A') goto yy916; + if (yych <= 'N') goto yy822; + goto yy915; + } else { + if (yych <= 'a') { + if (yych <= '`') goto yy822; + goto yy916; + } else { + if (yych == 'o') goto yy915; + goto yy822; + } + } +yy848: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'I') { + if (yych == 'D') goto yy858; + if (yych <= 'H') goto yy822; + goto yy914; + } else { + if (yych == 'L') goto yy858; + if (yych <= 'S') goto yy822; + goto yy858; + } + } else { + if (yych <= 'i') { + if (yych == 'd') goto yy858; + if (yych <= 'h') goto yy822; + goto yy914; + } else { + if (yych <= 'l') { + if (yych <= 'k') goto yy822; + goto yy858; + } else { + if (yych == 't') goto yy858; + goto yy822; + } + } + } +yy849: + yych = *++p; + if (yych <= 'T') { + if (yych <= 'D') { + if (yych == 'C') goto yy903; + goto yy822; + } else { + if (yych <= 'E') goto yy904; + if (yych <= 'S') goto yy822; + goto yy902; + } + } else { + if (yych <= 'd') { + if (yych == 'c') goto yy903; + goto yy822; + } else { + if (yych <= 'e') goto yy904; + if (yych == 't') goto yy902; + goto yy822; + } + } +yy850: + yych = *++p; + switch (yych) { + case 'A': + case 'a': goto yy888; + case 'B': + case 'b': goto yy887; + case 'D': + case 'R': + case 'd': + case 'r': goto yy858; + case 'E': + case 'e': goto yy886; + case 'F': + case 'f': goto yy885; + case 'H': + case 'h': goto yy884; + default: goto yy822; + } +yy851: + yych = *++p; + if (yych == 'M') goto yy881; + if (yych == 'm') goto yy881; + goto yy822; +yy852: + yych = *++p; + if (yych <= 'O') { + if (yych == 'I') goto yy862; + if (yych <= 'N') goto yy822; + goto yy861; + } else { + if (yych <= 'i') { + if (yych <= 'h') goto yy822; + goto yy862; + } else { + if (yych == 'o') goto yy861; + goto yy822; + } + } +yy853: + yych = *++p; + if (yych == 'L') goto yy858; + if (yych == 'l') goto yy858; + goto yy822; +yy854: + yych = *++p; + if (yych == 'I') goto yy855; + if (yych != 'i') goto yy822; +yy855: + yych = *++p; + if (yych == 'D') goto yy856; + if (yych != 'd') goto yy822; +yy856: + yych = *++p; + if (yych == 'E') goto yy857; + if (yych != 'e') goto yy822; +yy857: + yych = *++p; + if (yych == 'O') goto yy858; + if (yych != 'o') goto yy822; +yy858: + yych = *++p; + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych >= 0x0E) goto yy822; + } else { + if (yych <= ' ') goto yy859; + if (yych != '>') goto yy822; + } +yy859: + ++p; + { return (p - start); } +yy861: + yych = *++p; + if (yych <= 'R') { + if (yych == 'O') goto yy877; + if (yych <= 'Q') goto yy822; + goto yy878; + } else { + if (yych <= 'o') { + if (yych <= 'n') goto yy822; + goto yy877; + } else { + if (yych == 'r') goto yy878; + goto yy822; + } + } +yy862: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') goto yy863; + if (yych <= 'F') goto yy822; + goto yy864; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + } else { + if (yych == 'g') goto yy864; + goto yy822; + } + } +yy863: + yych = *++p; + if (yych == 'L') goto yy873; + if (yych == 'l') goto yy873; + goto yy822; +yy864: + yych = *++p; + if (yych <= 'U') { + if (yych == 'C') goto yy866; + if (yych <= 'T') goto yy822; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy822; + goto yy866; + } else { + if (yych != 'u') goto yy822; + } + } + yych = *++p; + if (yych == 'R') goto yy872; + if (yych == 'r') goto yy872; + goto yy822; +yy866: + yych = *++p; + if (yych == 'A') goto yy867; + if (yych != 'a') goto yy822; +yy867: + yych = *++p; + if (yych == 'P') goto yy868; + if (yych != 'p') goto yy822; +yy868: + yych = *++p; + if (yych == 'T') goto yy869; + if (yych != 't') goto yy822; +yy869: + yych = *++p; + if (yych == 'I') goto yy870; + if (yych != 'i') goto yy822; +yy870: + yych = *++p; + if (yych == 'O') goto yy871; + if (yych != 'o') goto yy822; +yy871: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy872: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy873: + yych = *++p; + if (yych == 'D') goto yy874; + if (yych != 'd') goto yy822; +yy874: + yych = *++p; + if (yych == 'S') goto yy875; + if (yych != 's') goto yy822; +yy875: + yych = *++p; + if (yych == 'E') goto yy876; + if (yych != 'e') goto yy822; +yy876: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy877: + yych = *++p; + if (yych == 'T') goto yy879; + if (yych == 't') goto yy879; + goto yy822; +yy878: + yych = *++p; + if (yych == 'M') goto yy858; + if (yych == 'm') goto yy858; + goto yy822; +yy879: + yych = *++p; + if (yych == 'E') goto yy880; + if (yych != 'e') goto yy822; +yy880: + yych = *++p; + if (yych == 'R') goto yy858; + if (yych == 'r') goto yy858; + goto yy822; +yy881: + yych = *++p; + if (yych == 'B') goto yy882; + if (yych != 'b') goto yy822; +yy882: + yych = *++p; + if (yych == 'E') goto yy883; + if (yych != 'e') goto yy822; +yy883: + yych = *++p; + if (yych == 'D') goto yy858; + if (yych == 'd') goto yy858; + goto yy822; +yy884: + yych = *++p; + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy822; + goto yy859; + } else { + if (yych == ' ') goto yy859; + goto yy822; + } + } else { + if (yych <= 'E') { + if (yych <= '>') goto yy859; + if (yych <= 'D') goto yy822; + goto yy900; + } else { + if (yych == 'e') goto yy900; + goto yy822; + } + } +yy885: + yych = *++p; + if (yych == 'O') goto yy898; + if (yych == 'o') goto yy898; + goto yy822; +yy886: + yych = *++p; + if (yych == 'X') goto yy893; + if (yych == 'x') goto yy893; + goto yy822; +yy887: + yych = *++p; + if (yych == 'O') goto yy891; + if (yych == 'o') goto yy891; + goto yy822; +yy888: + yych = *++p; + if (yych == 'B') goto yy889; + if (yych != 'b') goto yy822; +yy889: + yych = *++p; + if (yych == 'L') goto yy890; + if (yych != 'l') goto yy822; +yy890: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy891: + yych = *++p; + if (yych == 'D') goto yy892; + if (yych != 'd') goto yy822; +yy892: + yych = *++p; + if (yych == 'Y') goto yy858; + if (yych == 'y') goto yy858; + goto yy822; +yy893: + yych = *++p; + if (yych == 'T') goto yy894; + if (yych != 't') goto yy822; +yy894: + yych = *++p; + if (yych == 'A') goto yy895; + if (yych != 'a') goto yy822; +yy895: + yych = *++p; + if (yych == 'R') goto yy896; + if (yych != 'r') goto yy822; +yy896: + yych = *++p; + if (yych == 'E') goto yy897; + if (yych != 'e') goto yy822; +yy897: + yych = *++p; + if (yych == 'A') goto yy858; + if (yych == 'a') goto yy858; + goto yy822; +yy898: + yych = *++p; + if (yych == 'O') goto yy899; + if (yych != 'o') goto yy822; +yy899: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy900: + yych = *++p; + if (yych == 'A') goto yy901; + if (yych != 'a') goto yy822; +yy901: + yych = *++p; + if (yych == 'D') goto yy858; + if (yych == 'd') goto yy858; + goto yy822; +yy902: + yych = *++p; + if (yych == 'Y') goto yy912; + if (yych == 'y') goto yy912; + goto yy822; +yy903: + yych = *++p; + if (yych == 'R') goto yy909; + if (yych == 'r') goto yy909; + goto yy822; +yy904: + yych = *++p; + if (yych == 'C') goto yy905; + if (yych != 'c') goto yy822; +yy905: + yych = *++p; + if (yych == 'T') goto yy906; + if (yych != 't') goto yy822; +yy906: + yych = *++p; + if (yych == 'I') goto yy907; + if (yych != 'i') goto yy822; +yy907: + yych = *++p; + if (yych == 'O') goto yy908; + if (yych != 'o') goto yy822; +yy908: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy909: + yych = *++p; + if (yych == 'I') goto yy910; + if (yych != 'i') goto yy822; +yy910: + yych = *++p; + if (yych == 'P') goto yy911; + if (yych != 'p') goto yy822; +yy911: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy912: + yych = *++p; + if (yych == 'L') goto yy913; + if (yych != 'l') goto yy822; +yy913: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy914: + yych = *++p; + if (yych == 'V') goto yy858; + if (yych == 'v') goto yy858; + goto yy822; +yy915: + yych = *++p; + if (yych == 'L') goto yy924; + if (yych == 'l') goto yy924; + goto yy822; +yy916: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy917; + if (yych <= 'O') goto yy822; + goto yy918; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy822; + } else { + if (yych == 'p') goto yy918; + goto yy822; + } + } +yy917: + yych = *++p; + if (yych == 'V') goto yy922; + if (yych == 'v') goto yy922; + goto yy822; +yy918: + yych = *++p; + if (yych == 'T') goto yy919; + if (yych != 't') goto yy822; +yy919: + yych = *++p; + if (yych == 'I') goto yy920; + if (yych != 'i') goto yy822; +yy920: + yych = *++p; + if (yych == 'O') goto yy921; + if (yych != 'o') goto yy822; +yy921: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy922: + yych = *++p; + if (yych == 'A') goto yy923; + if (yych != 'a') goto yy822; +yy923: + yych = *++p; + if (yych == 'S') goto yy858; + if (yych == 's') goto yy858; + goto yy822; +yy924: + yych = *++p; + if (yych <= '=') { + if (yych <= '\r') { + if (yych <= 0x08) goto yy822; + goto yy859; + } else { + if (yych == ' ') goto yy859; + goto yy822; + } + } else { + if (yych <= 'G') { + if (yych <= '>') goto yy859; + if (yych <= 'F') goto yy822; + } else { + if (yych != 'g') goto yy822; + } + } + yych = *++p; + if (yych == 'R') goto yy926; + if (yych != 'r') goto yy822; +yy926: + yych = *++p; + if (yych == 'O') goto yy927; + if (yych != 'o') goto yy822; +yy927: + yych = *++p; + if (yych == 'U') goto yy928; + if (yych != 'u') goto yy822; +yy928: + yych = *++p; + if (yych == 'P') goto yy858; + if (yych == 'p') goto yy858; + goto yy822; +yy929: + yych = *++p; + if (yych == 'T') goto yy934; + if (yych == 't') goto yy934; + goto yy822; +yy930: + yych = *++p; + if (yych == 'J') goto yy931; + if (yych != 'j') goto yy822; +yy931: + yych = *++p; + if (yych == 'E') goto yy932; + if (yych != 'e') goto yy822; +yy932: + yych = *++p; + if (yych == 'C') goto yy933; + if (yych != 'c') goto yy822; +yy933: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy934: + yych = *++p; + if (yych == 'P') goto yy935; + if (yych != 'p') goto yy822; +yy935: + yych = *++p; + if (yych == 'U') goto yy936; + if (yych != 'u') goto yy822; +yy936: + yych = *++p; + if (yych == 'T') goto yy858; + if (yych == 't') goto yy858; + goto yy822; +yy937: + yych = *++p; + if (yych == 'P') goto yy858; + if (yych == 'p') goto yy858; + goto yy822; +yy938: + yych = *++p; + if (yych == 'T') goto yy949; + if (yych == 't') goto yy949; + goto yy822; +yy939: + yych = *++p; + if (yych == 'D') goto yy948; + if (yych == 'd') goto yy948; + goto yy822; +yy940: + yych = *++p; + if (yych == 'O') goto yy941; + if (yych != 'o') goto yy822; +yy941: + yych = *++p; + if (yych == 'C') goto yy942; + if (yych != 'c') goto yy822; +yy942: + yych = *++p; + if (yych == 'K') goto yy943; + if (yych != 'k') goto yy822; +yy943: + yych = *++p; + if (yych == 'Q') goto yy944; + if (yych != 'q') goto yy822; +yy944: + yych = *++p; + if (yych == 'U') goto yy945; + if (yych != 'u') goto yy822; +yy945: + yych = *++p; + if (yych == 'O') goto yy946; + if (yych != 'o') goto yy822; +yy946: + yych = *++p; + if (yych == 'T') goto yy947; + if (yych != 't') goto yy822; +yy947: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy948: + yych = *++p; + if (yych == 'Y') goto yy858; + if (yych == 'y') goto yy858; + goto yy822; +yy949: + yych = *++p; + if (yych == 'T') goto yy950; + if (yych != 't') goto yy822; +yy950: + yych = *++p; + if (yych == 'O') goto yy951; + if (yych != 'o') goto yy822; +yy951: + yych = *++p; + if (yych == 'N') goto yy858; + if (yych == 'n') goto yy858; + goto yy822; +yy952: + yych = *++p; + if (yych == 'R') goto yy953; + if (yych != 'r') goto yy822; +yy953: + yych = *++p; + if (yych == 'A') goto yy954; + if (yych != 'a') goto yy822; +yy954: + yych = *++p; + if (yych == 'M') goto yy955; + if (yych != 'm') goto yy822; +yy955: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy956: + yych = *++p; + if (yych == 'R') goto yy961; + if (yych == 'r') goto yy961; + goto yy822; +yy957: + yych = *++p; + if (yych == 'A') goto yy958; + if (yych != 'a') goto yy822; +yy958: + yych = *++p; + if (yych == 'D') goto yy959; + if (yych != 'd') goto yy822; +yy959: + yych = *++p; + if (yych == 'E') goto yy960; + if (yych != 'e') goto yy822; +yy960: + yych = *++p; + if (yych == 'R') goto yy858; + if (yych == 'r') goto yy858; + goto yy822; +yy961: + yych = *++p; + if (yych == 'O') goto yy962; + if (yych != 'o') goto yy822; +yy962: + yych = *++p; + if (yych == 'U') goto yy963; + if (yych != 'u') goto yy822; +yy963: + yych = *++p; + if (yych == 'P') goto yy858; + if (yych == 'p') goto yy858; + goto yy822; +yy964: + yych = *++p; + if (yych == 'I') goto yy970; + if (yych == 'i') goto yy970; + goto yy822; +yy965: + yych = *++p; + if (yych == 'T') goto yy966; + if (yych != 't') goto yy822; +yy966: + yych = *++p; + if (yych == 'I') goto yy967; + if (yych != 'i') goto yy822; +yy967: + yych = *++p; + if (yych == 'C') goto yy968; + if (yych != 'c') goto yy822; +yy968: + yych = *++p; + if (yych == 'L') goto yy969; + if (yych != 'l') goto yy822; +yy969: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy970: + yych = *++p; + if (yych == 'D') goto yy971; + if (yych != 'd') goto yy822; +yy971: + yych = *++p; + if (yych == 'E') goto yy858; + if (yych == 'e') goto yy858; + goto yy822; +yy972: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') goto yy858; + if (yych <= 'N') goto yy822; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + goto yy858; + } else { + if (yych != 'o') goto yy822; + } + } + yych = *++p; + if (yych == 'G') goto yy974; + if (yych != 'g') goto yy822; +yy974: + yych = *++p; + if (yych == 'R') goto yy975; + if (yych != 'r') goto yy822; +yy975: + yych = *++p; + if (yych == 'E') goto yy976; + if (yych != 'e') goto yy822; +yy976: + yych = *++p; + if (yych == 'S') goto yy977; + if (yych != 's') goto yy822; +yy977: + yych = *++p; + if (yych == 'S') goto yy858; + if (yych == 's') goto yy858; + goto yy822; +yy978: + yych = *++p; + if (yych == 'D') goto yy979; + if (yych != 'd') goto yy822; +yy979: + yych = *++p; + if (yych == 'E') goto yy980; + if (yych != 'e') goto yy822; +yy980: + yych = *++p; + if (yych == 'O') goto yy981; + if (yych != 'o') goto yy822; +yy981: + yych = *++p; + if (yych <= ' ') { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + if (yych <= 0x1F) goto yy822; + } else { + if (yych <= '/') { + if (yych <= '.') goto yy822; + } else { + if (yych != '>') goto yy822; + } + } +yy982: + ++p; + { return (p - start); } +yy984: + yych = *++p; + if (yych <= 'R') { + if (yych == 'O') goto yy1000; + if (yych <= 'Q') goto yy822; + goto yy1001; + } else { + if (yych <= 'o') { + if (yych <= 'n') goto yy822; + goto yy1000; + } else { + if (yych == 'r') goto yy1001; + goto yy822; + } + } +yy985: + yych = *++p; + if (yych <= 'G') { + if (yych == 'E') goto yy986; + if (yych <= 'F') goto yy822; + goto yy987; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + } else { + if (yych == 'g') goto yy987; + goto yy822; + } + } +yy986: + yych = *++p; + if (yych == 'L') goto yy996; + if (yych == 'l') goto yy996; + goto yy822; +yy987: + yych = *++p; + if (yych <= 'U') { + if (yych == 'C') goto yy989; + if (yych <= 'T') goto yy822; + } else { + if (yych <= 'c') { + if (yych <= 'b') goto yy822; + goto yy989; + } else { + if (yych != 'u') goto yy822; + } + } + yych = *++p; + if (yych == 'R') goto yy995; + if (yych == 'r') goto yy995; + goto yy822; +yy989: + yych = *++p; + if (yych == 'A') goto yy990; + if (yych != 'a') goto yy822; +yy990: + yych = *++p; + if (yych == 'P') goto yy991; + if (yych != 'p') goto yy822; +yy991: + yych = *++p; + if (yych == 'T') goto yy992; + if (yych != 't') goto yy822; +yy992: + yych = *++p; + if (yych == 'I') goto yy993; + if (yych != 'i') goto yy822; +yy993: + yych = *++p; + if (yych == 'O') goto yy994; + if (yych != 'o') goto yy822; +yy994: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy995: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy996: + yych = *++p; + if (yych == 'D') goto yy997; + if (yych != 'd') goto yy822; +yy997: + yych = *++p; + if (yych == 'S') goto yy998; + if (yych != 's') goto yy822; +yy998: + yych = *++p; + if (yych == 'E') goto yy999; + if (yych != 'e') goto yy822; +yy999: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1000: + yych = *++p; + if (yych == 'T') goto yy1002; + if (yych == 't') goto yy1002; + goto yy822; +yy1001: + yych = *++p; + if (yych == 'M') goto yy981; + if (yych == 'm') goto yy981; + goto yy822; +yy1002: + yych = *++p; + if (yych == 'E') goto yy1003; + if (yych != 'e') goto yy822; +yy1003: + yych = *++p; + if (yych == 'R') goto yy981; + if (yych == 'r') goto yy981; + goto yy822; +yy1004: + yych = *++p; + if (yych == 'B') goto yy1005; + if (yych != 'b') goto yy822; +yy1005: + yych = *++p; + if (yych == 'E') goto yy1006; + if (yych != 'e') goto yy822; +yy1006: + yych = *++p; + if (yych == 'D') goto yy981; + if (yych == 'd') goto yy981; + goto yy822; +yy1007: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + goto yy822; + } else { + if (yych <= ' ') goto yy982; + if (yych <= '.') goto yy822; + goto yy982; + } + } else { + if (yych <= 'D') { + if (yych == '>') goto yy982; + goto yy822; + } else { + if (yych <= 'E') goto yy1023; + if (yych == 'e') goto yy1023; + goto yy822; + } + } +yy1008: + yych = *++p; + if (yych == 'O') goto yy1021; + if (yych == 'o') goto yy1021; + goto yy822; +yy1009: + yych = *++p; + if (yych == 'X') goto yy1016; + if (yych == 'x') goto yy1016; + goto yy822; +yy1010: + yych = *++p; + if (yych == 'O') goto yy1014; + if (yych == 'o') goto yy1014; + goto yy822; +yy1011: + yych = *++p; + if (yych == 'B') goto yy1012; + if (yych != 'b') goto yy822; +yy1012: + yych = *++p; + if (yych == 'L') goto yy1013; + if (yych != 'l') goto yy822; +yy1013: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1014: + yych = *++p; + if (yych == 'D') goto yy1015; + if (yych != 'd') goto yy822; +yy1015: + yych = *++p; + if (yych == 'Y') goto yy981; + if (yych == 'y') goto yy981; + goto yy822; +yy1016: + yych = *++p; + if (yych == 'T') goto yy1017; + if (yych != 't') goto yy822; +yy1017: + yych = *++p; + if (yych == 'A') goto yy1018; + if (yych != 'a') goto yy822; +yy1018: + yych = *++p; + if (yych == 'R') goto yy1019; + if (yych != 'r') goto yy822; +yy1019: + yych = *++p; + if (yych == 'E') goto yy1020; + if (yych != 'e') goto yy822; +yy1020: + yych = *++p; + if (yych == 'A') goto yy981; + if (yych == 'a') goto yy981; + goto yy822; +yy1021: + yych = *++p; + if (yych == 'O') goto yy1022; + if (yych != 'o') goto yy822; +yy1022: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1023: + yych = *++p; + if (yych == 'A') goto yy1024; + if (yych != 'a') goto yy822; +yy1024: + yych = *++p; + if (yych == 'D') goto yy981; + if (yych == 'd') goto yy981; + goto yy822; +yy1025: + yych = *++p; + if (yych == 'Y') goto yy1035; + if (yych == 'y') goto yy1035; + goto yy822; +yy1026: + yych = *++p; + if (yych == 'R') goto yy1032; + if (yych == 'r') goto yy1032; + goto yy822; +yy1027: + yych = *++p; + if (yych == 'C') goto yy1028; + if (yych != 'c') goto yy822; +yy1028: + yych = *++p; + if (yych == 'T') goto yy1029; + if (yych != 't') goto yy822; +yy1029: + yych = *++p; + if (yych == 'I') goto yy1030; + if (yych != 'i') goto yy822; +yy1030: + yych = *++p; + if (yych == 'O') goto yy1031; + if (yych != 'o') goto yy822; +yy1031: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy1032: + yych = *++p; + if (yych == 'I') goto yy1033; + if (yych != 'i') goto yy822; +yy1033: + yych = *++p; + if (yych == 'P') goto yy1034; + if (yych != 'p') goto yy822; +yy1034: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1035: + yych = *++p; + if (yych == 'L') goto yy1036; + if (yych != 'l') goto yy822; +yy1036: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1037: + yych = *++p; + if (yych == 'V') goto yy981; + if (yych == 'v') goto yy981; + goto yy822; +yy1038: + yych = *++p; + if (yych == 'L') goto yy1047; + if (yych == 'l') goto yy1047; + goto yy822; +yy1039: + yych = *++p; + if (yych <= 'P') { + if (yych == 'N') goto yy1040; + if (yych <= 'O') goto yy822; + goto yy1041; + } else { + if (yych <= 'n') { + if (yych <= 'm') goto yy822; + } else { + if (yych == 'p') goto yy1041; + goto yy822; + } + } +yy1040: + yych = *++p; + if (yych == 'V') goto yy1045; + if (yych == 'v') goto yy1045; + goto yy822; +yy1041: + yych = *++p; + if (yych == 'T') goto yy1042; + if (yych != 't') goto yy822; +yy1042: + yych = *++p; + if (yych == 'I') goto yy1043; + if (yych != 'i') goto yy822; +yy1043: + yych = *++p; + if (yych == 'O') goto yy1044; + if (yych != 'o') goto yy822; +yy1044: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy1045: + yych = *++p; + if (yych == 'A') goto yy1046; + if (yych != 'a') goto yy822; +yy1046: + yych = *++p; + if (yych == 'S') goto yy981; + if (yych == 's') goto yy981; + goto yy822; +yy1047: + yych = *++p; + if (yych <= '/') { + if (yych <= 0x1F) { + if (yych <= 0x08) goto yy822; + if (yych <= '\r') goto yy982; + goto yy822; + } else { + if (yych <= ' ') goto yy982; + if (yych <= '.') goto yy822; + goto yy982; + } + } else { + if (yych <= 'F') { + if (yych == '>') goto yy982; + goto yy822; + } else { + if (yych <= 'G') goto yy1048; + if (yych != 'g') goto yy822; + } + } +yy1048: + yych = *++p; + if (yych == 'R') goto yy1049; + if (yych != 'r') goto yy822; +yy1049: + yych = *++p; + if (yych == 'O') goto yy1050; + if (yych != 'o') goto yy822; +yy1050: + yych = *++p; + if (yych == 'U') goto yy1051; + if (yych != 'u') goto yy822; +yy1051: + yych = *++p; + if (yych == 'P') goto yy981; + if (yych == 'p') goto yy981; + goto yy822; +yy1052: + yych = *++p; + if (yych == 'T') goto yy1057; + if (yych == 't') goto yy1057; + goto yy822; +yy1053: + yych = *++p; + if (yych == 'J') goto yy1054; + if (yych != 'j') goto yy822; +yy1054: + yych = *++p; + if (yych == 'E') goto yy1055; + if (yych != 'e') goto yy822; +yy1055: + yych = *++p; + if (yych == 'C') goto yy1056; + if (yych != 'c') goto yy822; +yy1056: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1057: + yych = *++p; + if (yych == 'P') goto yy1058; + if (yych != 'p') goto yy822; +yy1058: + yych = *++p; + if (yych == 'U') goto yy1059; + if (yych != 'u') goto yy822; +yy1059: + yych = *++p; + if (yych == 'T') goto yy981; + if (yych == 't') goto yy981; + goto yy822; +yy1060: + yych = *++p; + if (yych == 'P') goto yy981; + if (yych == 'p') goto yy981; + goto yy822; +yy1061: + yych = *++p; + if (yych == 'T') goto yy1072; + if (yych == 't') goto yy1072; + goto yy822; +yy1062: + yych = *++p; + if (yych == 'D') goto yy1071; + if (yych == 'd') goto yy1071; + goto yy822; +yy1063: + yych = *++p; + if (yych == 'O') goto yy1064; + if (yych != 'o') goto yy822; +yy1064: + yych = *++p; + if (yych == 'C') goto yy1065; + if (yych != 'c') goto yy822; +yy1065: + yych = *++p; + if (yych == 'K') goto yy1066; + if (yych != 'k') goto yy822; +yy1066: + yych = *++p; + if (yych == 'Q') goto yy1067; + if (yych != 'q') goto yy822; +yy1067: + yych = *++p; + if (yych == 'U') goto yy1068; + if (yych != 'u') goto yy822; +yy1068: + yych = *++p; + if (yych == 'O') goto yy1069; + if (yych != 'o') goto yy822; +yy1069: + yych = *++p; + if (yych == 'T') goto yy1070; + if (yych != 't') goto yy822; +yy1070: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1071: + yych = *++p; + if (yych == 'Y') goto yy981; + if (yych == 'y') goto yy981; + goto yy822; +yy1072: + yych = *++p; + if (yych == 'T') goto yy1073; + if (yych != 't') goto yy822; +yy1073: + yych = *++p; + if (yych == 'O') goto yy1074; + if (yych != 'o') goto yy822; +yy1074: + yych = *++p; + if (yych == 'N') goto yy981; + if (yych == 'n') goto yy981; + goto yy822; +yy1075: + yych = *++p; + if (yych == 'R') goto yy1076; + if (yych != 'r') goto yy822; +yy1076: + yych = *++p; + if (yych == 'A') goto yy1077; + if (yych != 'a') goto yy822; +yy1077: + yych = *++p; + if (yych == 'M') goto yy1078; + if (yych != 'm') goto yy822; +yy1078: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1079: + yych = *++p; + if (yych == 'R') goto yy1084; + if (yych == 'r') goto yy1084; + goto yy822; +yy1080: + yych = *++p; + if (yych == 'A') goto yy1081; + if (yych != 'a') goto yy822; +yy1081: + yych = *++p; + if (yych == 'D') goto yy1082; + if (yych != 'd') goto yy822; +yy1082: + yych = *++p; + if (yych == 'E') goto yy1083; + if (yych != 'e') goto yy822; +yy1083: + yych = *++p; + if (yych == 'R') goto yy981; + if (yych == 'r') goto yy981; + goto yy822; +yy1084: + yych = *++p; + if (yych == 'O') goto yy1085; + if (yych != 'o') goto yy822; +yy1085: + yych = *++p; + if (yych == 'U') goto yy1086; + if (yych != 'u') goto yy822; +yy1086: + yych = *++p; + if (yych == 'P') goto yy981; + if (yych == 'p') goto yy981; + goto yy822; +yy1087: + yych = *++p; + if (yych == 'I') goto yy1093; + if (yych == 'i') goto yy1093; + goto yy822; +yy1088: + yych = *++p; + if (yych == 'T') goto yy1089; + if (yych != 't') goto yy822; +yy1089: + yych = *++p; + if (yych == 'I') goto yy1090; + if (yych != 'i') goto yy822; +yy1090: + yych = *++p; + if (yych == 'C') goto yy1091; + if (yych != 'c') goto yy822; +yy1091: + yych = *++p; + if (yych == 'L') goto yy1092; + if (yych != 'l') goto yy822; +yy1092: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1093: + yych = *++p; + if (yych == 'D') goto yy1094; + if (yych != 'd') goto yy822; +yy1094: + yych = *++p; + if (yych == 'E') goto yy981; + if (yych == 'e') goto yy981; + goto yy822; +yy1095: + yych = *++p; + if (yych <= 'O') { + if (yych == 'E') goto yy981; + if (yych <= 'N') goto yy822; + } else { + if (yych <= 'e') { + if (yych <= 'd') goto yy822; + goto yy981; + } else { + if (yych != 'o') goto yy822; + } + } + yych = *++p; + if (yych == 'G') goto yy1097; + if (yych != 'g') goto yy822; +yy1097: + yych = *++p; + if (yych == 'R') goto yy1098; + if (yych != 'r') goto yy822; +yy1098: + yych = *++p; + if (yych == 'E') goto yy1099; + if (yych != 'e') goto yy822; +yy1099: + yych = *++p; + if (yych == 'S') goto yy1100; + if (yych != 's') goto yy822; +yy1100: + ++p; + if ((yych = *p) == 'S') goto yy981; + if (yych == 's') goto yy981; + goto yy822; +} + +} + +// Try to match a URL in a link or reference, return number of chars matched. +// This may optionally be contained in <..>; otherwise +// whitespace and unbalanced right parentheses aren't allowed. +// Newlines aren't ever allowed. +int _scan_link_url(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 8, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, + 72, 112, 112, 112, 112, 112, 112, 112, + 64, 64, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 16, 112, 16, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 128, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + 112, 112, 112, 112, 112, 112, 112, 112, + }; + yych = *p; + if (yych <= '(') { + if (yych <= 0x1F) { + if (yych == '\n') goto yy1104; + goto yy1112; + } else { + if (yych <= ' ') goto yy1106; + if (yych <= '\'') goto yy1108; + goto yy1111; + } + } else { + if (yych <= '<') { + if (yych <= ')') goto yy1112; + if (yych <= ';') goto yy1108; + goto yy1107; + } else { + if (yych == '\\') goto yy1109; + goto yy1108; + } + } +yy1103: + { return (p - start); } +yy1104: + yyaccept = 0; + marker = ++p; + yych = *p; +yy1105: + if (yybm[0+yych] & 8) { + goto yy1104; + } + if (yych <= ')') { + if (yych <= ' ') goto yy1103; + if (yych <= '\'') goto yy1117; + if (yych <= '(') goto yy1113; + goto yy1103; + } else { + if (yych <= '<') { + if (yych <= ';') goto yy1117; + goto yy1120; + } else { + if (yych == '\\') goto yy1119; + goto yy1117; + } + } +yy1106: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1105; +yy1107: + yyaccept = 0; + yych = *(marker = ++p); + if (yybm[0+yych] & 32) { + goto yy1120; + } + if (yych <= '\'') { + if (yych <= 0x00) goto yy1103; + if (yych == '\n') goto yy1103; + goto yy1127; + } else { + if (yych <= ')') { + if (yych <= '(') goto yy1125; + goto yy1127; + } else { + if (yych <= '=') goto yy1117; + if (yych <= '>') goto yy1122; + goto yy1124; + } + } +yy1108: + yyaccept = 0; + yych = *(marker = ++p); + goto yy1118; +yy1109: + ++p; + if ((yych = *p) <= '@') { + if (yych <= ' ') goto yy1110; + if (yych <= '/') goto yy1117; + if (yych >= ':') goto yy1117; + } else { + if (yych <= '`') { + if (yych >= '[') goto yy1117; + } else { + if (yych <= 'z') goto yy1110; + if (yych <= '~') goto yy1117; + } + } +yy1110: + { return 0; } +yy1111: + yyaccept = 1; + yych = *(marker = ++p); + if (yych <= ' ') goto yy1110; + if (yych == '(') goto yy1110; + goto yy1114; +yy1112: + yych = *++p; + goto yy1110; +yy1113: + ++p; + yych = *p; +yy1114: + if (yybm[0+yych] & 16) { + goto yy1113; + } + if (yych <= '(') goto yy1115; + if (yych <= ')') goto yy1117; + goto yy1116; +yy1115: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1103; + } else { + goto yy1110; + } + } else { + goto yy1123; + } +yy1116: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= ' ') goto yy1115; + if (yych <= '/') goto yy1113; + if (yych <= '9') goto yy1115; + goto yy1113; + } else { + if (yych <= '`') { + if (yych <= 'Z') goto yy1115; + goto yy1113; + } else { + if (yych <= 'z') goto yy1115; + if (yych <= '~') goto yy1113; + goto yy1115; + } + } +yy1117: + yyaccept = 0; + marker = ++p; + yych = *p; +yy1118: + if (yych <= '(') { + if (yych <= ' ') goto yy1103; + if (yych <= '\'') goto yy1117; + goto yy1113; + } else { + if (yych <= ')') goto yy1103; + if (yych != '\\') goto yy1117; + } +yy1119: + ++p; + yych = *p; + if (yych <= '@') { + if (yych <= ' ') goto yy1115; + if (yych <= '/') goto yy1117; + if (yych <= '9') goto yy1115; + goto yy1117; + } else { + if (yych <= '`') { + if (yych <= 'Z') goto yy1115; + goto yy1117; + } else { + if (yych <= 'z') goto yy1115; + if (yych <= '~') goto yy1117; + goto yy1115; + } + } +yy1120: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1120; + } + if (yych <= '\'') { + if (yych <= 0x00) goto yy1103; + if (yych == '\n') goto yy1103; + goto yy1127; + } else { + if (yych <= ')') { + if (yych <= '(') goto yy1125; + goto yy1127; + } else { + if (yych <= '=') goto yy1117; + if (yych >= '?') goto yy1124; + } + } +yy1122: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ' ') goto yy1123; + if (yych != ')') goto yy1118; +yy1123: + { return (p - start); } +yy1124: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x00) goto yy1115; + if (yych == '\n') goto yy1115; + goto yy1127; + } else { + if (yych <= '/') goto yy1120; + if (yych <= '9') goto yy1127; + if (yych <= '=') goto yy1120; + goto yy1137; + } + } else { + if (yych <= '\\') { + if (yych <= '@') goto yy1120; + if (yych <= 'Z') goto yy1127; + if (yych <= '[') goto yy1120; + goto yy1138; + } else { + if (yych <= '`') goto yy1120; + if (yych <= 'z') goto yy1127; + if (yych <= '~') goto yy1120; + goto yy1127; + } + } +yy1125: + ++p; + yych = *p; + if (yych <= ')') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1115; + if (yych >= '\n') goto yy1115; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1125; + if (yych >= ')') goto yy1120; + } + } else { + if (yych <= '=') { + if (yych == '<') goto yy1113; + goto yy1125; + } else { + if (yych <= '>') goto yy1133; + if (yych == '\\') goto yy1134; + goto yy1125; + } + } +yy1127: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1127; + } + if (yych <= '=') goto yy1115; + if (yych >= '?') goto yy1130; +yy1129: + yych = *++p; + goto yy1123; +yy1130: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1130; + } + if (yych <= '\n') { + if (yych <= 0x00) goto yy1115; + if (yych <= '\t') goto yy1127; + goto yy1115; + } else { + if (yych != '>') goto yy1127; + } + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1127; + } + if (yych <= '=') goto yy1123; + if (yych <= '>') goto yy1129; + goto yy1130; +yy1133: + yyaccept = 2; + yych = *(marker = ++p); + if (yych <= ' ') goto yy1123; + if (yych == '(') goto yy1123; + goto yy1114; +yy1134: + ++p; + yych = *p; + if (yych <= '>') { + if (yych <= ' ') { + if (yych <= 0x00) goto yy1115; + if (yych == '\n') goto yy1115; + goto yy1127; + } else { + if (yych <= '/') goto yy1125; + if (yych <= '9') goto yy1127; + if (yych <= '=') goto yy1125; + } + } else { + if (yych <= '\\') { + if (yych <= '@') goto yy1125; + if (yych <= 'Z') goto yy1127; + if (yych <= '[') goto yy1125; + goto yy1136; + } else { + if (yych <= '`') goto yy1125; + if (yych <= 'z') goto yy1127; + if (yych <= '~') goto yy1125; + goto yy1127; + } + } +yy1135: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yych <= ')') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1123; + if (yych <= '\t') goto yy1127; + goto yy1123; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1125; + if (yych <= '(') goto yy1127; + goto yy1120; + } + } else { + if (yych <= '=') { + if (yych == '<') goto yy1113; + goto yy1125; + } else { + if (yych <= '>') goto yy1133; + if (yych == '\\') goto yy1134; + goto yy1125; + } + } +yy1136: + ++p; + yych = *p; + if (yych <= '(') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1115; + if (yych <= '\t') goto yy1127; + goto yy1115; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1125; + goto yy1127; + } + } else { + if (yych <= '>') { + if (yych <= ')') goto yy1120; + if (yych <= '=') goto yy1125; + goto yy1135; + } else { + if (yych == '\\') goto yy1134; + goto yy1125; + } + } +yy1137: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1120; + } + if (yych <= '\'') { + if (yych <= 0x00) goto yy1123; + if (yych == '\n') goto yy1123; + goto yy1127; + } else { + if (yych <= ')') { + if (yych <= '(') goto yy1125; + goto yy1127; + } else { + if (yych <= '=') goto yy1117; + if (yych <= '>') goto yy1122; + goto yy1124; + } + } +yy1138: + yyaccept = 0; + marker = ++p; + yych = *p; + if (yych <= '(') { + if (yych <= '\n') { + if (yych <= 0x00) goto yy1103; + if (yych <= '\t') goto yy1127; + goto yy1103; + } else { + if (yych <= ' ') goto yy1127; + if (yych <= '\'') goto yy1120; + goto yy1125; + } + } else { + if (yych <= '>') { + if (yych <= ')') goto yy1127; + if (yych <= '=') goto yy1120; + goto yy1137; + } else { + if (yych == '\\') goto yy1124; + goto yy1120; + } + } +} + +} + +// Try to match a link title (in single quotes, in double quotes, or +// in parentheses), returning number of chars matched. Allow one +// level of internal nesting (quotes within quotes). +int _scan_link_title(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + unsigned int yyaccept = 0; + static const unsigned char yybm[] = { + 0, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 80, 208, 208, 208, 208, 144, + 208, 192, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 32, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + 208, 208, 208, 208, 208, 208, 208, 208, + }; + yych = *p; + if (yych <= '"') { + if (yych == '\n') goto yy1141; + if (yych <= '!') goto yy1145; + goto yy1142; + } else { + if (yych <= '&') goto yy1145; + if (yych <= '\'') goto yy1143; + if (yych <= '(') goto yy1144; + goto yy1145; + } +yy1141: + { return 0; } +yy1142: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1141; + goto yy1162; +yy1143: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1141; + goto yy1155; +yy1144: + yyaccept = 0; + yych = *(marker = ++p); + if (yych <= 0x00) goto yy1141; + goto yy1147; +yy1145: + yych = *++p; + goto yy1141; +yy1146: + ++p; + yych = *p; +yy1147: + if (yybm[0+yych] & 16) { + goto yy1146; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1151; + goto yy1149; +yy1148: + p = marker; + if (yyaccept <= 1) { + if (yyaccept == 0) { + goto yy1141; + } else { + goto yy1152; + } + } else { + if (yyaccept == 2) { + goto yy1159; + } else { + goto yy1166; + } + } +yy1149: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1146; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1153; + goto yy1149; +yy1151: + ++p; +yy1152: + { return (p - start); } +yy1153: + yyaccept = 1; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1146; + } + if (yych <= 0x00) goto yy1152; + if (yych <= '[') goto yy1151; + goto yy1149; +yy1154: + ++p; + yych = *p; +yy1155: + if (yybm[0+yych] & 64) { + goto yy1154; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1158; +yy1156: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1154; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1160; + goto yy1156; +yy1158: + ++p; +yy1159: + { return (p - start); } +yy1160: + yyaccept = 2; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1154; + } + if (yych <= 0x00) goto yy1159; + if (yych <= '[') goto yy1158; + goto yy1156; +yy1161: + ++p; + yych = *p; +yy1162: + if (yybm[0+yych] & 128) { + goto yy1161; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1165; +yy1163: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1161; + } + if (yych <= 0x00) goto yy1148; + if (yych <= '[') goto yy1167; + goto yy1163; +yy1165: + ++p; +yy1166: + { return (p - start); } +yy1167: + yyaccept = 3; + marker = ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1161; + } + if (yych <= 0x00) goto yy1166; + if (yych <= '[') goto yy1165; + goto yy1163; +} + +} + +// Match space characters, including newlines. +int _scan_spacechars(const unsigned char *p) +{ + const unsigned char *start = p; \ + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 128, 128, 128, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1174; + if (yych <= '\t') goto yy1171; + goto yy1172; + } else { + if (yych <= '\r') goto yy1171; + if (yych == ' ') goto yy1171; + goto yy1174; + } +yy1170: + { return (p - start); } +yy1171: + yych = *++p; + goto yy1173; +yy1172: + ++p; + yych = *p; +yy1173: + if (yybm[0+yych] & 128) { + goto yy1172; + } + goto yy1170; +yy1174: + ++p; + { return 0; } +} + +} + +// Match ATX header start. +int _scan_atx_header_start(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych == '\n') goto yy1178; + if (yych == '#') goto yy1179; + goto yy1180; +yy1178: + { return 0; } +yy1179: + yych = *(marker = ++p); + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych == '#') goto yy1185; + goto yy1178; +yy1180: + yych = *++p; + goto yy1178; +yy1181: + ++p; +yy1182: + { return (p - start); } +yy1183: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + goto yy1182; +yy1185: + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych == '#') goto yy1187; +yy1186: + p = marker; + goto yy1178; +yy1187: + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych != '#') goto yy1186; + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych != '#') goto yy1186; + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + if (yych != '#') goto yy1186; + ++p; + if (yybm[0+(yych = *p)] & 128) { + goto yy1183; + } + if (yych == '\n') goto yy1181; + goto yy1186; +} + +} + +// Match sexext header line. Return 1 for level-1 header, +// 2 for level-2, 0 for no match. +int _scan_setext_header_line(const unsigned char *p) +{ + const unsigned char *marker = NULL; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 64, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= ',') { + if (yych != '\n') goto yy1196; + } else { + if (yych <= '-') goto yy1195; + if (yych == '=') goto yy1194; + goto yy1196; + } +yy1193: + { return 0; } +yy1194: + yych = *(marker = ++p); + if (yybm[0+yych] & 128) { + goto yy1208; + } + if (yych == '\n') goto yy1206; + if (yych == ' ') goto yy1204; + goto yy1193; +yy1195: + yych = *(marker = ++p); + if (yybm[0+yych] & 32) { + goto yy1197; + } + if (yych == '\n') goto yy1200; + if (yych == '-') goto yy1202; + goto yy1193; +yy1196: + yych = *++p; + goto yy1193; +yy1197: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1197; + } + if (yych == '\n') goto yy1200; +yy1199: + p = marker; + goto yy1193; +yy1200: + ++p; + { return 2; } +yy1202: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1197; + } + if (yych == '\n') goto yy1200; + if (yych == '-') goto yy1202; + goto yy1199; +yy1204: + ++p; + yych = *p; + if (yych == '\n') goto yy1206; + if (yych == ' ') goto yy1204; + goto yy1199; +yy1206: + ++p; + { return 1; } +yy1208: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1208; + } + if (yych == '\n') goto yy1206; + if (yych == ' ') goto yy1204; + goto yy1199; +} + +} + +// Scan a horizontal rule line: "...three or more hyphens, asterisks, +// or underscores on a line by themselves. If you wish, you may use +// spaces between the hyphens or asterisks." +int _scan_hrule(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 32, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 128, 0, 0, 16, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 64, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '*') { + if (yych == '\n') goto yy1212; + if (yych <= ')') goto yy1216; + goto yy1213; + } else { + if (yych <= '-') { + if (yych <= ',') goto yy1216; + goto yy1215; + } else { + if (yych == '_') goto yy1214; + goto yy1216; + } + } +yy1212: + { return 0; } +yy1213: + yych = *(marker = ++p); + if (yych == ' ') goto yy1238; + if (yych == '*') goto yy1240; + goto yy1212; +yy1214: + yych = *(marker = ++p); + if (yych == ' ') goto yy1228; + if (yych == '_') goto yy1230; + goto yy1212; +yy1215: + yych = *(marker = ++p); + if (yybm[0+yych] & 8) { + goto yy1217; + } + if (yych == '-') goto yy1220; + goto yy1212; +yy1216: + yych = *++p; + goto yy1212; +yy1217: + ++p; + yych = *p; + if (yybm[0+yych] & 8) { + goto yy1217; + } + if (yych == '-') goto yy1220; +yy1219: + p = marker; + goto yy1212; +yy1220: + ++p; + yych = *p; + if (yych == ' ') goto yy1220; + if (yych != '-') goto yy1219; +yy1222: + ++p; + yych = *p; + if (yybm[0+yych] & 16) { + goto yy1222; + } + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1224; + if (yych <= '\n') goto yy1226; + goto yy1219; +yy1224: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1224; + } + if (yych != '\n') goto yy1219; +yy1226: + ++p; + { return (p - start); } +yy1228: + ++p; + yych = *p; + if (yych == ' ') goto yy1228; + if (yych != '_') goto yy1219; +yy1230: + ++p; + yych = *p; + if (yych == ' ') goto yy1230; + if (yych != '_') goto yy1219; +yy1232: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1232; + } + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1234; + if (yych <= '\n') goto yy1236; + goto yy1219; +yy1234: + ++p; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1234; + } else { + if (yych == ' ') goto yy1234; + goto yy1219; + } +yy1236: + ++p; + { return (p - start); } +yy1238: + ++p; + yych = *p; + if (yych == ' ') goto yy1238; + if (yych != '*') goto yy1219; +yy1240: + ++p; + yych = *p; + if (yych == ' ') goto yy1240; + if (yych != '*') goto yy1219; +yy1242: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1242; + } + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1244; + if (yych <= '\n') goto yy1246; + goto yy1219; +yy1244: + ++p; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1219; + if (yych <= '\t') goto yy1244; + } else { + if (yych == ' ') goto yy1244; + goto yy1219; + } +yy1246: + ++p; + { return (p - start); } +} + +} + +// Scan an opening code fence. +int _scan_open_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 0, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 96, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 144, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + 160, 160, 160, 160, 160, 160, 160, 160, + }; + yych = *p; + if (yych <= '_') { + if (yych != '\n') goto yy1253; + } else { + if (yych <= '`') goto yy1251; + if (yych == '~') goto yy1252; + goto yy1253; + } +yy1250: + { return 0; } +yy1251: + yych = *(marker = ++p); + if (yych == '`') goto yy1262; + goto yy1250; +yy1252: + yych = *(marker = ++p); + if (yych == '~') goto yy1254; + goto yy1250; +yy1253: + yych = *++p; + goto yy1250; +yy1254: + yych = *++p; + if (yybm[0+yych] & 16) { + goto yy1256; + } +yy1255: + p = marker; + goto yy1250; +yy1256: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1258; + } + if (yych <= 0x00) goto yy1255; + if (yych <= '}') goto yy1260; + goto yy1256; +yy1258: + ++p; + yych = *p; + if (yybm[0+yych] & 32) { + goto yy1258; + } + if (yych <= 0x00) goto yy1255; + if (yych >= '~') goto yy1255; +yy1260: + ++p; + p = marker; + { return (p - start); } +yy1262: + yych = *++p; + if (yybm[0+yych] & 64) { + goto yy1263; + } + goto yy1255; +yy1263: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1265; + } + if (yych <= 0x00) goto yy1255; + if (yych <= '_') goto yy1267; + goto yy1263; +yy1265: + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1265; + } + if (yych <= 0x00) goto yy1255; + if (yych >= '`') goto yy1255; +yy1267: + ++p; + p = marker; + { return (p - start); } +} + +} + +// Scan a closing code fence with length at least len. +int _scan_close_code_fence(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + static const unsigned char yybm[] = { + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 64, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 32, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }; + yych = *p; + if (yych <= '_') { + if (yych != '\n') goto yy1274; + } else { + if (yych <= '`') goto yy1272; + if (yych == '~') goto yy1273; + goto yy1274; + } +yy1271: + { return 0; } +yy1272: + yych = *(marker = ++p); + if (yych == '`') goto yy1283; + goto yy1271; +yy1273: + yych = *(marker = ++p); + if (yych == '~') goto yy1275; + goto yy1271; +yy1274: + yych = *++p; + goto yy1271; +yy1275: + yych = *++p; + if (yybm[0+yych] & 32) { + goto yy1277; + } +yy1276: + p = marker; + goto yy1271; +yy1277: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1279; + } + if (yych == '\n') goto yy1281; + if (yych == '~') goto yy1277; + goto yy1276; +yy1279: + ++p; + yych = *p; + if (yybm[0+yych] & 64) { + goto yy1279; + } + if (yych != '\n') goto yy1276; +yy1281: + ++p; + p = marker; + { return (p - start); } +yy1283: + yych = *++p; + if (yybm[0+yych] & 128) { + goto yy1284; + } + goto yy1276; +yy1284: + marker = p + 1; + ++p; + yych = *p; + if (yybm[0+yych] & 128) { + goto yy1284; + } + if (yych <= '\n') { + if (yych <= 0x08) goto yy1276; + if (yych >= '\n') goto yy1288; + } else { + if (yych != ' ') goto yy1276; + } +yy1286: + ++p; + yych = *p; + if (yych <= '\n') { + if (yych <= 0x08) goto yy1276; + if (yych <= '\t') goto yy1286; + } else { + if (yych == ' ') goto yy1286; + goto yy1276; + } +yy1288: + ++p; + p = marker; + { return (p - start); } +} + +} + +// Scans an entity. +// Returns number of chars matched. +int _scan_entity(const unsigned char *p) +{ + const unsigned char *marker = NULL; + const unsigned char *start = p; + +{ + unsigned char yych; + yych = *p; + if (yych == '\n') goto yy1292; + if (yych == '&') goto yy1293; + goto yy1294; +yy1292: + { return 0; } +yy1293: + yych = *(marker = ++p); + if (yych <= '@') { + if (yych == '#') goto yy1295; + goto yy1292; + } else { + if (yych <= 'Z') goto yy1297; + if (yych <= '`') goto yy1292; + if (yych <= 'z') goto yy1297; + goto yy1292; + } +yy1294: + yych = *++p; + goto yy1292; +yy1295: + yych = *++p; + if (yych <= 'W') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1332; + } else { + if (yych <= 'X') goto yy1331; + if (yych == 'x') goto yy1331; + } +yy1296: + p = marker; + goto yy1292; +yy1297: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy1296; + if (yych >= ':') goto yy1296; + } else { + if (yych <= 'Z') goto yy1298; + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } +yy1298: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1301; + if (yych <= ':') goto yy1296; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + goto yy1301; + } else { + if (yych <= '`') goto yy1296; + if (yych <= 'z') goto yy1301; + goto yy1296; + } + } +yy1299: + ++p; + { return (p - start); } +yy1301: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1302; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1302: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1303; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1303: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1304; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1304: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1305; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1305: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1306; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1306: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1307; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1307: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1308; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1308: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1309; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1309: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1310; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1310: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1311; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1311: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1312; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1312: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1313; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1313: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1314; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1314: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1315; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1315: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1316; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1316: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1317; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1317: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1318; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1318: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1319; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1319: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1320; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1320: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1321; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1321: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1322; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1322: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1323; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1323: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1324; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1324: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1325; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1325: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1326; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1326: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1327; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1327: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1328; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1328: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1329; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1329: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1330; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'Z') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= '{') goto yy1296; + } + } +yy1330: + yych = *++p; + if (yych == ';') goto yy1299; + goto yy1296; +yy1331: + yych = *++p; + if (yych <= '@') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1339; + goto yy1296; + } else { + if (yych <= 'F') goto yy1339; + if (yych <= '`') goto yy1296; + if (yych <= 'f') goto yy1339; + goto yy1296; + } +yy1332: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1333; + if (yych == ';') goto yy1299; + goto yy1296; +yy1333: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1334; + if (yych == ';') goto yy1299; + goto yy1296; +yy1334: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1335; + if (yych == ';') goto yy1299; + goto yy1296; +yy1335: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1336; + if (yych == ';') goto yy1299; + goto yy1296; +yy1336: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1337; + if (yych == ';') goto yy1299; + goto yy1296; +yy1337: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1338; + if (yych == ';') goto yy1299; + goto yy1296; +yy1338: + yych = *++p; + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1330; + if (yych == ';') goto yy1299; + goto yy1296; +yy1339: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1340; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1340: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1341; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1341: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1342; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1342: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1343; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1343: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1344; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1344: + yych = *++p; + if (yych <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1345; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + } else { + if (yych <= '`') goto yy1296; + if (yych >= 'g') goto yy1296; + } + } +yy1345: + ++p; + if ((yych = *p) <= ';') { + if (yych <= '/') goto yy1296; + if (yych <= '9') goto yy1330; + if (yych <= ':') goto yy1296; + goto yy1299; + } else { + if (yych <= 'F') { + if (yych <= '@') goto yy1296; + goto yy1330; + } else { + if (yych <= '`') goto yy1296; + if (yych <= 'f') goto yy1330; + goto yy1296; + } + } +} + +} diff --git a/cmark/scanners.h b/cmark/scanners.h new file mode 100644 --- /dev/null +++ b/cmark/scanners.h @@ -0,0 +1,39 @@ +#include "cmark.h" +#include "chunk.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int _scan_at(int (*scanner)(const unsigned char *), cmark_chunk *c, int offset); +int _scan_autolink_uri(const unsigned char *p); +int _scan_autolink_email(const unsigned char *p); +int _scan_html_tag(const unsigned char *p); +int _scan_html_block_tag(const unsigned char *p); +int _scan_link_url(const unsigned char *p); +int _scan_link_title(const unsigned char *p); +int _scan_spacechars(const unsigned char *p); +int _scan_atx_header_start(const unsigned char *p); +int _scan_setext_header_line(const unsigned char *p); +int _scan_hrule(const unsigned char *p); +int _scan_open_code_fence(const unsigned char *p); +int _scan_close_code_fence(const unsigned char *p); +int _scan_entity(const unsigned char *p); + +#define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n) +#define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n) +#define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n) +#define scan_html_block_tag(c, n) _scan_at(&_scan_html_block_tag, c, n) +#define scan_link_url(c, n) _scan_at(&_scan_link_url, c, n) +#define scan_link_title(c, n) _scan_at(&_scan_link_title, c, n) +#define scan_spacechars(c, n) _scan_at(&_scan_spacechars, c, n) +#define scan_atx_header_start(c, n) _scan_at(&_scan_atx_header_start, c, n) +#define scan_setext_header_line(c, n) _scan_at(&_scan_setext_header_line, c, n) +#define scan_hrule(c, n) _scan_at(&_scan_hrule, c, n) +#define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n) +#define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n) +#define scan_entity(c, n) _scan_at(&_scan_entity, c, n) + +#ifdef __cplusplus +} +#endif diff --git a/cmark/utf8.c b/cmark/utf8.c new file mode 100644 --- /dev/null +++ b/cmark/utf8.c @@ -0,0 +1,453 @@ +#include +#include +#include + +#include "cmark_ctype.h" +#include "utf8.h" + +static const int8_t utf8proc_utf8class[256] = { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static void encode_unknown(cmark_strbuf *buf) +{ + static const uint8_t repl[] = {239, 191, 189}; + cmark_strbuf_put(buf, repl, 3); +} + +static int utf8proc_charlen(const uint8_t *str, int str_len) +{ + int length, i; + + if (!str_len) + return 0; + + length = utf8proc_utf8class[str[0]]; + + if (!length) + return -1; + + if (str_len >= 0 && length > str_len) + return -str_len; + + for (i = 1; i < length; i++) { + if ((str[i] & 0xC0) != 0x80) + return -i; + } + + return length; +} + +// Validate a single UTF-8 character according to RFC 3629. +static int utf8proc_valid(const uint8_t *str, int str_len) +{ + int length = utf8proc_charlen(str, str_len); + + if (length <= 0) + return length; + + switch (length) { + case 1: + if (str[0] == 0x00) { + // ASCII NUL is technically valid but rejected + // for security reasons. + return -length; + } + break; + + case 2: + if (str[0] < 0xC2) { + // Overlong + return -length; + } + break; + + case 3: + if (str[0] == 0xE0) { + if (str[1] < 0xA0) { + // Overlong + return -length; + } + } else if (str[0] == 0xED) { + if (str[1] >= 0xA0) { + // Surrogate + return -length; + } + } + break; + + case 4: + if (str[0] == 0xF0) { + if (str[1] < 0x90) { + // Overlong + return -length; + } + } else if (str[0] >= 0xF4) { + if (str[0] > 0xF4 || str[1] >= 0x90) { + // Above 0x10FFFF + return -length; + } + } + break; + } + + return length; +} + +void utf8proc_detab(cmark_strbuf *ob, const uint8_t *line, size_t size) +{ + static const uint8_t whitespace[] = " "; + + size_t i = 0, tab = 0; + + while (i < size) { + size_t org = i; + + while (i < size && line[i] != '\t' && line[i] != '\0' + && line[i] < 0x80) { + i++; + tab++; + } + + if (i > org) + cmark_strbuf_put(ob, line + org, i - org); + + if (i >= size) + break; + + if (line[i] == '\t') { + int numspaces = 4 - (tab % 4); + cmark_strbuf_put(ob, whitespace, numspaces); + i += 1; + tab += numspaces; + } else { + int charlen = utf8proc_valid(line + i, size - i); + + if (charlen >= 0) { + cmark_strbuf_put(ob, line + i, charlen); + } else { + encode_unknown(ob); + charlen = -charlen; + } + + i += charlen; + tab += 1; + } + } +} + +int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst) +{ + int length; + int32_t uc = -1; + + *dst = -1; + length = utf8proc_charlen(str, str_len); + if (length < 0) + return -1; + + switch (length) { + case 1: + uc = str[0]; + break; + case 2: + uc = ((str[0] & 0x1F) << 6) + (str[1] & 0x3F); + if (uc < 0x80) uc = -1; + break; + case 3: + uc = ((str[0] & 0x0F) << 12) + ((str[1] & 0x3F) << 6) + + (str[2] & 0x3F); + if (uc < 0x800 || (uc >= 0xD800 && uc < 0xE000) || + (uc >= 0xFDD0 && uc < 0xFDF0)) uc = -1; + break; + case 4: + uc = ((str[0] & 0x07) << 18) + ((str[1] & 0x3F) << 12) + + ((str[2] & 0x3F) << 6) + (str[3] & 0x3F); + if (uc < 0x10000 || uc >= 0x110000) uc = -1; + break; + } + + if (uc < 0 || ((uc & 0xFFFF) >= 0xFFFE)) + return -1; + + *dst = uc; + return length; +} + +void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) +{ + uint8_t dst[4]; + int len = 0; + + assert(uc >= 0); + + if (uc < 0x80) { + dst[0] = uc; + len = 1; + } else if (uc < 0x800) { + dst[0] = 0xC0 + (uc >> 6); + dst[1] = 0x80 + (uc & 0x3F); + len = 2; + } else if (uc == 0xFFFF) { + dst[0] = 0xFF; + len = 1; + } else if (uc == 0xFFFE) { + dst[0] = 0xFE; + len = 1; + } else if (uc < 0x10000) { + dst[0] = 0xE0 + (uc >> 12); + dst[1] = 0x80 + ((uc >> 6) & 0x3F); + dst[2] = 0x80 + (uc & 0x3F); + len = 3; + } else if (uc < 0x110000) { + dst[0] = 0xF0 + (uc >> 18); + dst[1] = 0x80 + ((uc >> 12) & 0x3F); + dst[2] = 0x80 + ((uc >> 6) & 0x3F); + dst[3] = 0x80 + (uc & 0x3F); + len = 4; + } else { + encode_unknown(buf); + return; + } + + cmark_strbuf_put(buf, dst, len); +} + +void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len) +{ + int32_t c; + +#define bufpush(x) \ + utf8proc_encode_char(x, dest) + + while (len > 0) { + int char_len = utf8proc_iterate(str, len, &c); + + if (char_len >= 0) { +#include "case_fold_switch.inc" + } else { + encode_unknown(dest); + char_len = -char_len; + } + + str += char_len; + len -= char_len; + } +} + +// matches anything in the Zs class, plus LF, CR, TAB, FF. +int utf8proc_is_space(int32_t uc) +{ + return (uc == 9 || + uc == 10 || + uc == 12 || + uc == 13 || + uc == 32 || + uc == 160 || + uc == 5760 || + (uc >= 8192 && uc <= 8202) || + uc == 8239 || + uc == 8287 || + uc == 12288); +} + +// matches anything in the P[cdefios] classes. +int utf8proc_is_punctuation(int32_t uc) +{ + return ((uc < 128 && cmark_ispunct((char)uc)) || + uc == 161 || + uc == 167 || + uc == 171 || + uc == 182 || + uc == 183 || + uc == 187 || + uc == 191 || + uc == 894 || + uc == 903 || + (uc >= 1370 && uc <= 1375) || + uc == 1417 || + uc == 1418 || + uc == 1470 || + uc == 1472 || + uc == 1475 || + uc == 1478 || + uc == 1523 || + uc == 1524 || + uc == 1545 || + uc == 1546 || + uc == 1548 || + uc == 1549 || + uc == 1563 || + uc == 1566 || + uc == 1567 || + (uc >= 1642 && uc <= 1645) || + uc == 1748 || + (uc >= 1792 && uc <= 1805) || + (uc >= 2039 && uc <= 2041) || + (uc >= 2096 && uc <= 2110) || + uc == 2142 || + uc == 2404 || + uc == 2405 || + uc == 2416 || + uc == 2800 || + uc == 3572 || + uc == 3663 || + uc == 3674 || + uc == 3675 || + (uc >= 3844 && uc <= 3858) || + uc == 3860 || + (uc >= 3898 && uc <= 3901) || + uc == 3973 || + (uc >= 4048 && uc <= 4052) || + uc == 4057 || + uc == 4058 || + (uc >= 4170 && uc <= 4175) || + uc == 4347 || + (uc >= 4960 && uc <= 4968) || + uc == 5120 || + uc == 5741 || + uc == 5742 || + uc == 5787 || + uc == 5788 || + (uc >= 5867 && uc <= 5869) || + uc == 5941 || + uc == 5942 || + (uc >= 6100 && uc <= 6102) || + (uc >= 6104 && uc <= 6106) || + (uc >= 6144 && uc <= 6154) || + uc == 6468 || + uc == 6469 || + uc == 6686 || + uc == 6687 || + (uc >= 6816 && uc <= 6822) || + (uc >= 6824 && uc <= 6829) || + (uc >= 7002 && uc <= 7008) || + (uc >= 7164 && uc <= 7167) || + (uc >= 7227 && uc <= 7231) || + uc == 7294 || + uc == 7295 || + (uc >= 7360 && uc <= 7367) || + uc == 7379 || + (uc >= 8208 && uc <= 8231) || + (uc >= 8240 && uc <= 8259) || + (uc >= 8261 && uc <= 8273) || + (uc >= 8275 && uc <= 8286) || + uc == 8317 || + uc == 8318 || + uc == 8333 || + uc == 8334 || + (uc >= 8968 && uc <= 8971) || + uc == 9001 || + uc == 9002 || + (uc >= 10088 && uc <= 10101) || + uc == 10181 || + uc == 10182 || + (uc >= 10214 && uc <= 10223) || + (uc >= 10627 && uc <= 10648) || + (uc >= 10712 && uc <= 10715) || + uc == 10748 || + uc == 10749 || + (uc >= 11513 && uc <= 11516) || + uc == 11518 || + uc == 11519 || + uc == 11632 || + (uc >= 11776 && uc <= 11822) || + (uc >= 11824 && uc <= 11842) || + (uc >= 12289 && uc <= 12291) || + (uc >= 12296 && uc <= 12305) || + (uc >= 12308 && uc <= 12319) || + uc == 12336 || + uc == 12349 || + uc == 12448 || + uc == 12539 || + uc == 42238 || + uc == 42239 || + (uc >= 42509 && uc <= 42511) || + uc == 42611 || + uc == 42622 || + (uc >= 42738 && uc <= 42743) || + (uc >= 43124 && uc <= 43127) || + uc == 43214 || + uc == 43215 || + (uc >= 43256 && uc <= 43258) || + uc == 43310 || + uc == 43311 || + uc == 43359 || + (uc >= 43457 && uc <= 43469) || + uc == 43486 || + uc == 43487 || + (uc >= 43612 && uc <= 43615) || + uc == 43742 || + uc == 43743 || + uc == 43760 || + uc == 43761 || + uc == 44011 || + uc == 64830 || + uc == 64831 || + (uc >= 65040 && uc <= 65049) || + (uc >= 65072 && uc <= 65106) || + (uc >= 65108 && uc <= 65121) || + uc == 65123 || + uc == 65128 || + uc == 65130 || + uc == 65131 || + (uc >= 65281 && uc <= 65283) || + (uc >= 65285 && uc <= 65290) || + (uc >= 65292 && uc <= 65295) || + uc == 65306 || + uc == 65307 || + uc == 65311 || + uc == 65312 || + (uc >= 65339 && uc <= 65341) || + uc == 65343 || + uc == 65371 || + uc == 65373 || + (uc >= 65375 && uc <= 65381) || + (uc >= 65792 && uc <= 65794) || + uc == 66463 || + uc == 66512 || + uc == 66927 || + uc == 67671 || + uc == 67871 || + uc == 67903 || + (uc >= 68176 && uc <= 68184) || + uc == 68223 || + (uc >= 68336 && uc <= 68342) || + (uc >= 68409 && uc <= 68415) || + (uc >= 68505 && uc <= 68508) || + (uc >= 69703 && uc <= 69709) || + uc == 69819 || + uc == 69820 || + (uc >= 69822 && uc <= 69825) || + (uc >= 69952 && uc <= 69955) || + uc == 70004 || + uc == 70005 || + (uc >= 70085 && uc <= 70088) || + uc == 70093 || + (uc >= 70200 && uc <= 70205) || + uc == 70854 || + (uc >= 71105 && uc <= 71113) || + (uc >= 71233 && uc <= 71235) || + (uc >= 74864 && uc <= 74868) || + uc == 92782 || + uc == 92783 || + uc == 92917 || + (uc >= 92983 && uc <= 92987) || + uc == 92996 || + uc == 113823); +} diff --git a/cmark/utf8.h b/cmark/utf8.h new file mode 100644 --- /dev/null +++ b/cmark/utf8.h @@ -0,0 +1,22 @@ +#ifndef CMARK_UTF8_H +#define CMARK_UTF8_H + +#include +#include "buffer.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len); +void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf); +int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst); +void utf8proc_detab(cmark_strbuf *dest, const uint8_t *line, size_t size); +int utf8proc_is_space(int32_t uc); +int utf8proc_is_punctuation(int32_t uc); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/cmark/xml.c b/cmark/xml.c new file mode 100644 --- /dev/null +++ b/cmark/xml.c @@ -0,0 +1,170 @@ +#include +#include +#include +#include + +#include "config.h" +#include "cmark.h" +#include "node.h" +#include "buffer.h" +#include "houdini.h" + +// Functions to convert cmark_nodes to XML strings. + +static void escape_xml(cmark_strbuf *dest, const unsigned char *source, int length) +{ + if (source != NULL) { + if (length < 0) + length = strlen((char *)source); + + houdini_escape_html0(dest, source, (size_t)length, 0); + } +} + +struct render_state { + cmark_strbuf* xml; + int indent; +}; + +static inline void indent(struct render_state *state) +{ + int i; + for (i = 0; i < state->indent; i++) { + cmark_strbuf_putc(state->xml, ' '); + } +} + +static int +S_render_node(cmark_node *node, cmark_event_type ev_type, + struct render_state *state, int options) +{ + cmark_strbuf *xml = state->xml; + bool literal = false; + cmark_delim_type delim; + bool entering = (ev_type == CMARK_EVENT_ENTER); + + if (entering) { + indent(state); + cmark_strbuf_printf(xml, "<%s", + cmark_node_get_type_string(node)); + + if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) { + cmark_strbuf_printf(xml, " sourcepos=\"%d:%d-%d:%d\"", + node->start_line, + node->start_column, + node->end_line, + node->end_column); + } + + literal = false; + + switch (node->type) { + case CMARK_NODE_TEXT: + case CMARK_NODE_CODE: + case CMARK_NODE_HTML: + case CMARK_NODE_INLINE_HTML: + cmark_strbuf_puts(xml, ">"); + escape_xml(xml, node->as.literal.data, + node->as.literal.len); + cmark_strbuf_puts(xml, "as.header.level); + break; + case CMARK_NODE_CODE_BLOCK: + if (node->as.code.info.len > 0) { + cmark_strbuf_puts(xml, " info=\""); + escape_xml(xml, node->as.code.info.data, + node->as.code.info.len); + cmark_strbuf_putc(xml, '"'); + } + cmark_strbuf_puts(xml, ">"); + escape_xml(xml, node->as.code.literal.data, + node->as.code.literal.len); + cmark_strbuf_puts(xml, "as.link.url, -1); + cmark_strbuf_putc(xml, '"'); + cmark_strbuf_puts(xml, " title=\""); + escape_xml(xml, node->as.link.title, -1); + cmark_strbuf_putc(xml, '"'); + break; + default: + break; + } + if (node->first_child) { + state->indent += 2; + } else if (!literal) { + cmark_strbuf_puts(xml, " /"); + } + cmark_strbuf_puts(xml, ">\n"); + + + } else if (node->first_child) { + state->indent -= 2; + indent(state); + cmark_strbuf_printf(xml, "\n", + cmark_node_get_type_string(node)); + } + + return 1; +} + +char *cmark_render_xml(cmark_node *root, int options) +{ + char *result; + cmark_strbuf xml = GH_BUF_INIT; + cmark_event_type ev_type; + cmark_node *cur; + struct render_state state = { &xml, 0 }; + + cmark_iter *iter = cmark_iter_new(root); + + cmark_strbuf_puts(state.xml, + "\n"); + cmark_strbuf_puts(state.xml, + "\n"); + while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) { + cur = cmark_iter_get_node(iter); + S_render_node(cur, ev_type, &state, options); + } + result = (char *)cmark_strbuf_detach(&xml); + + cmark_iter_free(iter); + return result; +}