001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.7
002package com.puppycrawl.tools.checkstyle.grammars.javadoc;
003import org.antlr.v4.runtime.atn.*;
004import org.antlr.v4.runtime.dfa.DFA;
005import org.antlr.v4.runtime.*;
006import org.antlr.v4.runtime.misc.*;
007import org.antlr.v4.runtime.tree.*;
008import java.util.List;
009import java.util.Iterator;
010import java.util.ArrayList;
011
012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
013public class JavadocParser extends Parser {
014        static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
015
016        protected static final DFA[] _decisionToDFA;
017        protected static final PredictionContextCache _sharedContextCache =
018                new PredictionContextCache();
019        public static final int
020                LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, START=5, NEWLINE=6, 
021                AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 
022                RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 
023                SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 
024                JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 
025                LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 
026                STRING=27, PACKAGE_CLASS=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 
027                LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 
028                Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 
029                DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 
030                LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, END=55, 
031                SLASH_END=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 
032                TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 
033                COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 
034                HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 
035                TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 
036                BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 
037                COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 
038                INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 
039                META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, EMBED_HTML_TAG_NAME=87, 
040                KEYGEN_HTML_TAG_NAME=88, ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91, 
041                SOURCE_HTML_TAG_NAME=92, TRACK_HTML_TAG_NAME=93, WBR_HTML_TAG_NAME=94, 
042                HTML_TAG_NAME=95, Char11=96;
043        public static final int
044                RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementStart = 2, RULE_htmlElementEnd = 3, 
045                RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagStart = 6, RULE_pTagEnd = 7, 
046                RULE_paragraph = 8, RULE_liTagStart = 9, RULE_liTagEnd = 10, RULE_li = 11, 
047                RULE_trTagStart = 12, RULE_trTagEnd = 13, RULE_tr = 14, RULE_tdTagStart = 15, 
048                RULE_tdTagEnd = 16, RULE_td = 17, RULE_thTagStart = 18, RULE_thTagEnd = 19, 
049                RULE_th = 20, RULE_bodyTagStart = 21, RULE_bodyTagEnd = 22, RULE_body = 23, 
050                RULE_colgroupTagStart = 24, RULE_colgroupTagEnd = 25, RULE_colgroup = 26, 
051                RULE_ddTagStart = 27, RULE_ddTagEnd = 28, RULE_dd = 29, RULE_dtTagStart = 30, 
052                RULE_dtTagEnd = 31, RULE_dt = 32, RULE_headTagStart = 33, RULE_headTagEnd = 34, 
053                RULE_head = 35, RULE_htmlTagStart = 36, RULE_htmlTagEnd = 37, RULE_html = 38, 
054                RULE_optionTagStart = 39, RULE_optionTagEnd = 40, RULE_option = 41, RULE_tbodyTagStart = 42, 
055                RULE_tbodyTagEnd = 43, RULE_tbody = 44, RULE_tfootTagStart = 45, RULE_tfootTagEnd = 46, 
056                RULE_tfoot = 47, RULE_theadTagStart = 48, RULE_theadTagEnd = 49, RULE_thead = 50, 
057                RULE_singletonElement = 51, RULE_emptyTag = 52, RULE_areaTag = 53, RULE_baseTag = 54, 
058                RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, RULE_frameTag = 58, 
059                RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, RULE_isindexTag = 62, 
060                RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, RULE_wrongSinletonTag = 66, 
061                RULE_singletonTagName = 67, RULE_description = 68, RULE_reference = 69, 
062                RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 
063                RULE_htmlComment = 73, RULE_text = 74, RULE_embedTag = 75, RULE_keygenTag = 76, 
064                RULE_sourceTag = 77, RULE_trackTag = 78, RULE_wbrTag = 79;
065        public static final String[] ruleNames = {
066                "javadoc", "htmlElement", "htmlElementStart", "htmlElementEnd", "attribute", 
067                "htmlTag", "pTagStart", "pTagEnd", "paragraph", "liTagStart", "liTagEnd", 
068                "li", "trTagStart", "trTagEnd", "tr", "tdTagStart", "tdTagEnd", "td", 
069                "thTagStart", "thTagEnd", "th", "bodyTagStart", "bodyTagEnd", "body", 
070                "colgroupTagStart", "colgroupTagEnd", "colgroup", "ddTagStart", "ddTagEnd", 
071                "dd", "dtTagStart", "dtTagEnd", "dt", "headTagStart", "headTagEnd", "head", 
072                "htmlTagStart", "htmlTagEnd", "html", "optionTagStart", "optionTagEnd", 
073                "option", "tbodyTagStart", "tbodyTagEnd", "tbody", "tfootTagStart", "tfootTagEnd", 
074                "tfoot", "theadTagStart", "theadTagEnd", "thead", "singletonElement", 
075                "emptyTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", "frameTag", 
076                "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", "paramTag", 
077                "wrongSinletonTag", "singletonTagName", "description", "reference", "parameters", 
078                "javadocTag", "javadocInlineTag", "htmlComment", "text", "embedTag", "keygenTag", 
079                "sourceTag", "trackTag", "wbrTag"
080        };
081
082        private static final String[] _LITERAL_NAMES = {
083                null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 
084                null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 
085                null, "'@version'", null, null, null, "'include'", "'exclude'", null, 
086                null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 
087                "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 
088                "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 
089                "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 
090                null, null, null, null, null, null, null, null, null, null, null, null, 
091                null, null, null, null, null, null, null, null, null, null, "'-->'"
092        };
093        private static final String[] _SYMBOLIC_NAMES = {
094                null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "START", 
095                "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 
096                "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 
097                "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 
098                "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 
099                "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE_CLASS", 
100                "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 
101                "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 
102                "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 
103                "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 
104                "Char7", "Char8", "Char10", "END", "SLASH_END", "SLASH", "EQUALS", "P_HTML_TAG_NAME", 
105                "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", 
106                "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", 
107                "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", 
108                "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", 
109                "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", 
110                "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 
111                "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "EMBED_HTML_TAG_NAME", 
112                "KEYGEN_HTML_TAG_NAME", "ATTR_VALUE", "Char12", "HTML_COMMENT_END", "SOURCE_HTML_TAG_NAME", 
113                "TRACK_HTML_TAG_NAME", "WBR_HTML_TAG_NAME", "HTML_TAG_NAME", "Char11"
114        };
115        public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
116
117        /**
118         * @deprecated Use {@link #VOCABULARY} instead.
119         */
120        @Deprecated
121        public static final String[] tokenNames;
122        static {
123                tokenNames = new String[_SYMBOLIC_NAMES.length];
124                for (int i = 0; i < tokenNames.length; i++) {
125                        tokenNames[i] = VOCABULARY.getLiteralName(i);
126                        if (tokenNames[i] == null) {
127                                tokenNames[i] = VOCABULARY.getSymbolicName(i);
128                        }
129
130                        if (tokenNames[i] == null) {
131                                tokenNames[i] = "<INVALID>";
132                        }
133                }
134        }
135
136        @Override
137        @Deprecated
138        public String[] getTokenNames() {
139                return tokenNames;
140        }
141
142        @Override
143
144        public Vocabulary getVocabulary() {
145                return VOCABULARY;
146        }
147
148        @Override
149        public String getGrammarFileName() { return "JavadocParser.g4"; }
150
151        @Override
152        public String[] getRuleNames() { return ruleNames; }
153
154        @Override
155        public String getSerializedATN() { return _serializedATN; }
156
157        @Override
158        public ATN getATN() { return _ATN; }
159
160
161            boolean isNextJavadocTag() {
162                int token1 = _input.LA(2);
163                int token2 = _input.LA(3);
164                return isJavadocTag(token1)
165                    || (token1 == WS && isJavadocTag(token2));
166            }
167
168            boolean isJavadocTag(int type) {
169                switch(type) {
170                    case AUTHOR_LITERAL:
171                    case DEPRECATED_LITERAL:
172                    case EXCEPTION_LITERAL:
173                    case PARAM_LITERAL:
174                    case RETURN_LITERAL:
175                    case SEE_LITERAL:
176                    case SERIAL_LITERAL:
177                    case SERIAL_FIELD_LITERAL:
178                    case SERIAL_DATA_LITERAL:
179                    case SINCE_LITERAL:
180                    case THROWS_LITERAL:
181                    case VERSION_LITERAL:
182                    case CUSTOM_NAME:
183                        return true;
184                    default:
185                        return false;
186                }
187            }
188
189            boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) {
190                  String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
191                  String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
192                  return startTag.equals(endTag);
193            }
194
195            public ParserRuleContext nonTightTagStartContext;
196
197        public JavadocParser(TokenStream input) {
198                super(input);
199                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
200        }
201        public static class JavadocContext extends ParserRuleContext {
202                public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
203                public List<HtmlElementContext> htmlElement() {
204                        return getRuleContexts(HtmlElementContext.class);
205                }
206                public HtmlElementContext htmlElement(int i) {
207                        return getRuleContext(HtmlElementContext.class,i);
208                }
209                public List<HtmlCommentContext> htmlComment() {
210                        return getRuleContexts(HtmlCommentContext.class);
211                }
212                public HtmlCommentContext htmlComment(int i) {
213                        return getRuleContext(HtmlCommentContext.class,i);
214                }
215                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
216                public TerminalNode CDATA(int i) {
217                        return getToken(JavadocParser.CDATA, i);
218                }
219                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
220                public TerminalNode NEWLINE(int i) {
221                        return getToken(JavadocParser.NEWLINE, i);
222                }
223                public List<TextContext> text() {
224                        return getRuleContexts(TextContext.class);
225                }
226                public TextContext text(int i) {
227                        return getRuleContext(TextContext.class,i);
228                }
229                public List<JavadocInlineTagContext> javadocInlineTag() {
230                        return getRuleContexts(JavadocInlineTagContext.class);
231                }
232                public JavadocInlineTagContext javadocInlineTag(int i) {
233                        return getRuleContext(JavadocInlineTagContext.class,i);
234                }
235                public List<JavadocTagContext> javadocTag() {
236                        return getRuleContexts(JavadocTagContext.class);
237                }
238                public JavadocTagContext javadocTag(int i) {
239                        return getRuleContext(JavadocTagContext.class,i);
240                }
241                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
242                public TerminalNode LEADING_ASTERISK(int i) {
243                        return getToken(JavadocParser.LEADING_ASTERISK, i);
244                }
245                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
246                public TerminalNode WS(int i) {
247                        return getToken(JavadocParser.WS, i);
248                }
249                public JavadocContext(ParserRuleContext parent, int invokingState) {
250                        super(parent, invokingState);
251                }
252                @Override public int getRuleIndex() { return RULE_javadoc; }
253        }
254
255        public final JavadocContext javadoc() throws RecognitionException {
256                JavadocContext _localctx = new JavadocContext(_ctx, getState());
257                enterRule(_localctx, 0, RULE_javadoc);
258                int _la;
259                try {
260                        int _alt;
261                        enterOuterAlt(_localctx, 1);
262                        {
263                        setState(170);
264                        _errHandler.sync(this);
265                        _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
266                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
267                                if ( _alt==1 ) {
268                                        {
269                                        setState(168);
270                                        _errHandler.sync(this);
271                                        switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
272                                        case 1:
273                                                {
274                                                setState(160);
275                                                htmlElement();
276                                                }
277                                                break;
278                                        case 2:
279                                                {
280                                                {
281                                                setState(161);
282                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
283                                                setState(162);
284                                                match(LEADING_ASTERISK);
285                                                }
286                                                }
287                                                break;
288                                        case 3:
289                                                {
290                                                setState(163);
291                                                htmlComment();
292                                                }
293                                                break;
294                                        case 4:
295                                                {
296                                                setState(164);
297                                                match(CDATA);
298                                                }
299                                                break;
300                                        case 5:
301                                                {
302                                                setState(165);
303                                                match(NEWLINE);
304                                                }
305                                                break;
306                                        case 6:
307                                                {
308                                                setState(166);
309                                                text();
310                                                }
311                                                break;
312                                        case 7:
313                                                {
314                                                setState(167);
315                                                javadocInlineTag();
316                                                }
317                                                break;
318                                        }
319                                        } 
320                                }
321                                setState(172);
322                                _errHandler.sync(this);
323                                _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
324                        }
325                        setState(185);
326                        _errHandler.sync(this);
327                        _la = _input.LA(1);
328                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << AUTHOR_LITERAL) | (1L << DEPRECATED_LITERAL) | (1L << EXCEPTION_LITERAL) | (1L << PARAM_LITERAL) | (1L << RETURN_LITERAL) | (1L << SEE_LITERAL) | (1L << SERIAL_LITERAL) | (1L << SERIAL_FIELD_LITERAL) | (1L << SERIAL_DATA_LITERAL) | (1L << SINCE_LITERAL) | (1L << THROWS_LITERAL) | (1L << VERSION_LITERAL) | (1L << CUSTOM_NAME))) != 0)) {
329                                {
330                                {
331                                setState(174);
332                                _errHandler.sync(this);
333                                _la = _input.LA(1);
334                                if (_la==LEADING_ASTERISK) {
335                                        {
336                                        setState(173);
337                                        match(LEADING_ASTERISK);
338                                        }
339                                }
340
341                                setState(179);
342                                _errHandler.sync(this);
343                                _la = _input.LA(1);
344                                while (_la==WS) {
345                                        {
346                                        {
347                                        setState(176);
348                                        match(WS);
349                                        }
350                                        }
351                                        setState(181);
352                                        _errHandler.sync(this);
353                                        _la = _input.LA(1);
354                                }
355                                setState(182);
356                                javadocTag();
357                                }
358                                }
359                                setState(187);
360                                _errHandler.sync(this);
361                                _la = _input.LA(1);
362                        }
363                        setState(188);
364                        match(EOF);
365                        }
366                }
367                catch (RecognitionException re) {
368                        _localctx.exception = re;
369                        _errHandler.reportError(this, re);
370                        _errHandler.recover(this, re);
371                }
372                finally {
373                        exitRule();
374                }
375                return _localctx;
376        }
377
378        public static class HtmlElementContext extends ParserRuleContext {
379                public HtmlTagContext htmlTag() {
380                        return getRuleContext(HtmlTagContext.class,0);
381                }
382                public SingletonElementContext singletonElement() {
383                        return getRuleContext(SingletonElementContext.class,0);
384                }
385                public ParagraphContext paragraph() {
386                        return getRuleContext(ParagraphContext.class,0);
387                }
388                public LiContext li() {
389                        return getRuleContext(LiContext.class,0);
390                }
391                public TrContext tr() {
392                        return getRuleContext(TrContext.class,0);
393                }
394                public TdContext td() {
395                        return getRuleContext(TdContext.class,0);
396                }
397                public ThContext th() {
398                        return getRuleContext(ThContext.class,0);
399                }
400                public BodyContext body() {
401                        return getRuleContext(BodyContext.class,0);
402                }
403                public ColgroupContext colgroup() {
404                        return getRuleContext(ColgroupContext.class,0);
405                }
406                public DdContext dd() {
407                        return getRuleContext(DdContext.class,0);
408                }
409                public DtContext dt() {
410                        return getRuleContext(DtContext.class,0);
411                }
412                public HeadContext head() {
413                        return getRuleContext(HeadContext.class,0);
414                }
415                public HtmlContext html() {
416                        return getRuleContext(HtmlContext.class,0);
417                }
418                public OptionContext option() {
419                        return getRuleContext(OptionContext.class,0);
420                }
421                public TbodyContext tbody() {
422                        return getRuleContext(TbodyContext.class,0);
423                }
424                public TheadContext thead() {
425                        return getRuleContext(TheadContext.class,0);
426                }
427                public TfootContext tfoot() {
428                        return getRuleContext(TfootContext.class,0);
429                }
430                public PTagStartContext pTagStart() {
431                        return getRuleContext(PTagStartContext.class,0);
432                }
433                public LiTagStartContext liTagStart() {
434                        return getRuleContext(LiTagStartContext.class,0);
435                }
436                public TrTagStartContext trTagStart() {
437                        return getRuleContext(TrTagStartContext.class,0);
438                }
439                public TdTagStartContext tdTagStart() {
440                        return getRuleContext(TdTagStartContext.class,0);
441                }
442                public ThTagStartContext thTagStart() {
443                        return getRuleContext(ThTagStartContext.class,0);
444                }
445                public BodyTagStartContext bodyTagStart() {
446                        return getRuleContext(BodyTagStartContext.class,0);
447                }
448                public ColgroupTagStartContext colgroupTagStart() {
449                        return getRuleContext(ColgroupTagStartContext.class,0);
450                }
451                public DdTagStartContext ddTagStart() {
452                        return getRuleContext(DdTagStartContext.class,0);
453                }
454                public DtTagStartContext dtTagStart() {
455                        return getRuleContext(DtTagStartContext.class,0);
456                }
457                public HeadTagStartContext headTagStart() {
458                        return getRuleContext(HeadTagStartContext.class,0);
459                }
460                public HtmlTagStartContext htmlTagStart() {
461                        return getRuleContext(HtmlTagStartContext.class,0);
462                }
463                public OptionTagStartContext optionTagStart() {
464                        return getRuleContext(OptionTagStartContext.class,0);
465                }
466                public TbodyTagStartContext tbodyTagStart() {
467                        return getRuleContext(TbodyTagStartContext.class,0);
468                }
469                public TheadTagStartContext theadTagStart() {
470                        return getRuleContext(TheadTagStartContext.class,0);
471                }
472                public TfootTagStartContext tfootTagStart() {
473                        return getRuleContext(TfootTagStartContext.class,0);
474                }
475                public PTagEndContext pTagEnd() {
476                        return getRuleContext(PTagEndContext.class,0);
477                }
478                public LiTagEndContext liTagEnd() {
479                        return getRuleContext(LiTagEndContext.class,0);
480                }
481                public TrTagEndContext trTagEnd() {
482                        return getRuleContext(TrTagEndContext.class,0);
483                }
484                public TdTagEndContext tdTagEnd() {
485                        return getRuleContext(TdTagEndContext.class,0);
486                }
487                public ThTagEndContext thTagEnd() {
488                        return getRuleContext(ThTagEndContext.class,0);
489                }
490                public BodyTagEndContext bodyTagEnd() {
491                        return getRuleContext(BodyTagEndContext.class,0);
492                }
493                public ColgroupTagEndContext colgroupTagEnd() {
494                        return getRuleContext(ColgroupTagEndContext.class,0);
495                }
496                public DdTagEndContext ddTagEnd() {
497                        return getRuleContext(DdTagEndContext.class,0);
498                }
499                public DtTagEndContext dtTagEnd() {
500                        return getRuleContext(DtTagEndContext.class,0);
501                }
502                public HeadTagEndContext headTagEnd() {
503                        return getRuleContext(HeadTagEndContext.class,0);
504                }
505                public HtmlTagEndContext htmlTagEnd() {
506                        return getRuleContext(HtmlTagEndContext.class,0);
507                }
508                public OptionTagEndContext optionTagEnd() {
509                        return getRuleContext(OptionTagEndContext.class,0);
510                }
511                public TbodyTagEndContext tbodyTagEnd() {
512                        return getRuleContext(TbodyTagEndContext.class,0);
513                }
514                public TheadTagEndContext theadTagEnd() {
515                        return getRuleContext(TheadTagEndContext.class,0);
516                }
517                public TfootTagEndContext tfootTagEnd() {
518                        return getRuleContext(TfootTagEndContext.class,0);
519                }
520                public HtmlElementContext(ParserRuleContext parent, int invokingState) {
521                        super(parent, invokingState);
522                }
523                @Override public int getRuleIndex() { return RULE_htmlElement; }
524        }
525
526        public final HtmlElementContext htmlElement() throws RecognitionException {
527                HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
528                enterRule(_localctx, 2, RULE_htmlElement);
529                try {
530                        setState(237);
531                        _errHandler.sync(this);
532                        switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
533                        case 1:
534                                enterOuterAlt(_localctx, 1);
535                                {
536                                setState(190);
537                                htmlTag();
538                                }
539                                break;
540                        case 2:
541                                enterOuterAlt(_localctx, 2);
542                                {
543                                setState(191);
544                                singletonElement();
545                                }
546                                break;
547                        case 3:
548                                enterOuterAlt(_localctx, 3);
549                                {
550                                setState(192);
551                                paragraph();
552                                }
553                                break;
554                        case 4:
555                                enterOuterAlt(_localctx, 4);
556                                {
557                                setState(193);
558                                li();
559                                }
560                                break;
561                        case 5:
562                                enterOuterAlt(_localctx, 5);
563                                {
564                                setState(194);
565                                tr();
566                                }
567                                break;
568                        case 6:
569                                enterOuterAlt(_localctx, 6);
570                                {
571                                setState(195);
572                                td();
573                                }
574                                break;
575                        case 7:
576                                enterOuterAlt(_localctx, 7);
577                                {
578                                setState(196);
579                                th();
580                                }
581                                break;
582                        case 8:
583                                enterOuterAlt(_localctx, 8);
584                                {
585                                setState(197);
586                                body();
587                                }
588                                break;
589                        case 9:
590                                enterOuterAlt(_localctx, 9);
591                                {
592                                setState(198);
593                                colgroup();
594                                }
595                                break;
596                        case 10:
597                                enterOuterAlt(_localctx, 10);
598                                {
599                                setState(199);
600                                dd();
601                                }
602                                break;
603                        case 11:
604                                enterOuterAlt(_localctx, 11);
605                                {
606                                setState(200);
607                                dt();
608                                }
609                                break;
610                        case 12:
611                                enterOuterAlt(_localctx, 12);
612                                {
613                                setState(201);
614                                head();
615                                }
616                                break;
617                        case 13:
618                                enterOuterAlt(_localctx, 13);
619                                {
620                                setState(202);
621                                html();
622                                }
623                                break;
624                        case 14:
625                                enterOuterAlt(_localctx, 14);
626                                {
627                                setState(203);
628                                option();
629                                }
630                                break;
631                        case 15:
632                                enterOuterAlt(_localctx, 15);
633                                {
634                                setState(204);
635                                tbody();
636                                }
637                                break;
638                        case 16:
639                                enterOuterAlt(_localctx, 16);
640                                {
641                                setState(205);
642                                thead();
643                                }
644                                break;
645                        case 17:
646                                enterOuterAlt(_localctx, 17);
647                                {
648                                setState(206);
649                                tfoot();
650                                }
651                                break;
652                        case 18:
653                                enterOuterAlt(_localctx, 18);
654                                {
655                                setState(207);
656                                pTagStart(true);
657                                }
658                                break;
659                        case 19:
660                                enterOuterAlt(_localctx, 19);
661                                {
662                                setState(208);
663                                liTagStart(true);
664                                }
665                                break;
666                        case 20:
667                                enterOuterAlt(_localctx, 20);
668                                {
669                                setState(209);
670                                trTagStart(true);
671                                }
672                                break;
673                        case 21:
674                                enterOuterAlt(_localctx, 21);
675                                {
676                                setState(210);
677                                tdTagStart(true);
678                                }
679                                break;
680                        case 22:
681                                enterOuterAlt(_localctx, 22);
682                                {
683                                setState(211);
684                                thTagStart(true);
685                                }
686                                break;
687                        case 23:
688                                enterOuterAlt(_localctx, 23);
689                                {
690                                setState(212);
691                                bodyTagStart(true);
692                                }
693                                break;
694                        case 24:
695                                enterOuterAlt(_localctx, 24);
696                                {
697                                setState(213);
698                                colgroupTagStart(true);
699                                }
700                                break;
701                        case 25:
702                                enterOuterAlt(_localctx, 25);
703                                {
704                                setState(214);
705                                ddTagStart(true);
706                                }
707                                break;
708                        case 26:
709                                enterOuterAlt(_localctx, 26);
710                                {
711                                setState(215);
712                                dtTagStart(true);
713                                }
714                                break;
715                        case 27:
716                                enterOuterAlt(_localctx, 27);
717                                {
718                                setState(216);
719                                headTagStart(true);
720                                }
721                                break;
722                        case 28:
723                                enterOuterAlt(_localctx, 28);
724                                {
725                                setState(217);
726                                htmlTagStart(true);
727                                }
728                                break;
729                        case 29:
730                                enterOuterAlt(_localctx, 29);
731                                {
732                                setState(218);
733                                optionTagStart(true);
734                                }
735                                break;
736                        case 30:
737                                enterOuterAlt(_localctx, 30);
738                                {
739                                setState(219);
740                                tbodyTagStart(true);
741                                }
742                                break;
743                        case 31:
744                                enterOuterAlt(_localctx, 31);
745                                {
746                                setState(220);
747                                theadTagStart(true);
748                                }
749                                break;
750                        case 32:
751                                enterOuterAlt(_localctx, 32);
752                                {
753                                setState(221);
754                                tfootTagStart(true);
755                                }
756                                break;
757                        case 33:
758                                enterOuterAlt(_localctx, 33);
759                                {
760                                setState(222);
761                                pTagEnd();
762                                }
763                                break;
764                        case 34:
765                                enterOuterAlt(_localctx, 34);
766                                {
767                                setState(223);
768                                liTagEnd();
769                                }
770                                break;
771                        case 35:
772                                enterOuterAlt(_localctx, 35);
773                                {
774                                setState(224);
775                                trTagEnd();
776                                }
777                                break;
778                        case 36:
779                                enterOuterAlt(_localctx, 36);
780                                {
781                                setState(225);
782                                tdTagEnd();
783                                }
784                                break;
785                        case 37:
786                                enterOuterAlt(_localctx, 37);
787                                {
788                                setState(226);
789                                thTagEnd();
790                                }
791                                break;
792                        case 38:
793                                enterOuterAlt(_localctx, 38);
794                                {
795                                setState(227);
796                                bodyTagEnd();
797                                }
798                                break;
799                        case 39:
800                                enterOuterAlt(_localctx, 39);
801                                {
802                                setState(228);
803                                colgroupTagEnd();
804                                }
805                                break;
806                        case 40:
807                                enterOuterAlt(_localctx, 40);
808                                {
809                                setState(229);
810                                ddTagEnd();
811                                }
812                                break;
813                        case 41:
814                                enterOuterAlt(_localctx, 41);
815                                {
816                                setState(230);
817                                dtTagEnd();
818                                }
819                                break;
820                        case 42:
821                                enterOuterAlt(_localctx, 42);
822                                {
823                                setState(231);
824                                headTagEnd();
825                                }
826                                break;
827                        case 43:
828                                enterOuterAlt(_localctx, 43);
829                                {
830                                setState(232);
831                                htmlTagEnd();
832                                }
833                                break;
834                        case 44:
835                                enterOuterAlt(_localctx, 44);
836                                {
837                                setState(233);
838                                optionTagEnd();
839                                }
840                                break;
841                        case 45:
842                                enterOuterAlt(_localctx, 45);
843                                {
844                                setState(234);
845                                tbodyTagEnd();
846                                }
847                                break;
848                        case 46:
849                                enterOuterAlt(_localctx, 46);
850                                {
851                                setState(235);
852                                theadTagEnd();
853                                }
854                                break;
855                        case 47:
856                                enterOuterAlt(_localctx, 47);
857                                {
858                                setState(236);
859                                tfootTagEnd();
860                                }
861                                break;
862                        }
863                }
864                catch (RecognitionException re) {
865                        _localctx.exception = re;
866                        _errHandler.reportError(this, re);
867                        _errHandler.recover(this, re);
868                }
869                finally {
870                        exitRule();
871                }
872                return _localctx;
873        }
874
875        public static class HtmlElementStartContext extends ParserRuleContext {
876                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
877                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
878                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
879                public List<AttributeContext> attribute() {
880                        return getRuleContexts(AttributeContext.class);
881                }
882                public AttributeContext attribute(int i) {
883                        return getRuleContext(AttributeContext.class,i);
884                }
885                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
886                public TerminalNode NEWLINE(int i) {
887                        return getToken(JavadocParser.NEWLINE, i);
888                }
889                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
890                public TerminalNode LEADING_ASTERISK(int i) {
891                        return getToken(JavadocParser.LEADING_ASTERISK, i);
892                }
893                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
894                public TerminalNode WS(int i) {
895                        return getToken(JavadocParser.WS, i);
896                }
897                public HtmlElementStartContext(ParserRuleContext parent, int invokingState) {
898                        super(parent, invokingState);
899                }
900                @Override public int getRuleIndex() { return RULE_htmlElementStart; }
901        }
902
903        public final HtmlElementStartContext htmlElementStart() throws RecognitionException {
904                HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState());
905                enterRule(_localctx, 4, RULE_htmlElementStart);
906                int _la;
907                try {
908                        enterOuterAlt(_localctx, 1);
909                        {
910                        setState(239);
911                        match(START);
912                        setState(240);
913                        match(HTML_TAG_NAME);
914                        setState(247);
915                        _errHandler.sync(this);
916                        _la = _input.LA(1);
917                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
918                                {
919                                setState(245);
920                                _errHandler.sync(this);
921                                switch (_input.LA(1)) {
922                                case HTML_TAG_NAME:
923                                        {
924                                        setState(241);
925                                        attribute();
926                                        }
927                                        break;
928                                case NEWLINE:
929                                        {
930                                        setState(242);
931                                        match(NEWLINE);
932                                        }
933                                        break;
934                                case LEADING_ASTERISK:
935                                        {
936                                        setState(243);
937                                        match(LEADING_ASTERISK);
938                                        }
939                                        break;
940                                case WS:
941                                        {
942                                        setState(244);
943                                        match(WS);
944                                        }
945                                        break;
946                                default:
947                                        throw new NoViableAltException(this);
948                                }
949                                }
950                                setState(249);
951                                _errHandler.sync(this);
952                                _la = _input.LA(1);
953                        }
954                        setState(250);
955                        match(END);
956                        }
957                }
958                catch (RecognitionException re) {
959                        _localctx.exception = re;
960                        _errHandler.reportError(this, re);
961                        _errHandler.recover(this, re);
962                }
963                finally {
964                        exitRule();
965                }
966                return _localctx;
967        }
968
969        public static class HtmlElementEndContext extends ParserRuleContext {
970                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
971                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
972                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
973                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
974                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
975                public TerminalNode NEWLINE(int i) {
976                        return getToken(JavadocParser.NEWLINE, i);
977                }
978                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
979                public TerminalNode LEADING_ASTERISK(int i) {
980                        return getToken(JavadocParser.LEADING_ASTERISK, i);
981                }
982                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
983                public TerminalNode WS(int i) {
984                        return getToken(JavadocParser.WS, i);
985                }
986                public HtmlElementEndContext(ParserRuleContext parent, int invokingState) {
987                        super(parent, invokingState);
988                }
989                @Override public int getRuleIndex() { return RULE_htmlElementEnd; }
990        }
991
992        public final HtmlElementEndContext htmlElementEnd() throws RecognitionException {
993                HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState());
994                enterRule(_localctx, 6, RULE_htmlElementEnd);
995                int _la;
996                try {
997                        enterOuterAlt(_localctx, 1);
998                        {
999                        setState(252);
1000                        match(START);
1001                        setState(253);
1002                        match(SLASH);
1003                        setState(254);
1004                        match(HTML_TAG_NAME);
1005                        setState(258);
1006                        _errHandler.sync(this);
1007                        _la = _input.LA(1);
1008                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1009                                {
1010                                {
1011                                setState(255);
1012                                _la = _input.LA(1);
1013                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1014                                _errHandler.recoverInline(this);
1015                                }
1016                                else {
1017                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1018                                        _errHandler.reportMatch(this);
1019                                        consume();
1020                                }
1021                                }
1022                                }
1023                                setState(260);
1024                                _errHandler.sync(this);
1025                                _la = _input.LA(1);
1026                        }
1027                        setState(261);
1028                        match(END);
1029                        }
1030                }
1031                catch (RecognitionException re) {
1032                        _localctx.exception = re;
1033                        _errHandler.reportError(this, re);
1034                        _errHandler.recover(this, re);
1035                }
1036                finally {
1037                        exitRule();
1038                }
1039                return _localctx;
1040        }
1041
1042        public static class AttributeContext extends ParserRuleContext {
1043                public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
1044                public TerminalNode HTML_TAG_NAME(int i) {
1045                        return getToken(JavadocParser.HTML_TAG_NAME, i);
1046                }
1047                public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
1048                public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
1049                public TextContext text() {
1050                        return getRuleContext(TextContext.class,0);
1051                }
1052                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1053                public TerminalNode NEWLINE(int i) {
1054                        return getToken(JavadocParser.NEWLINE, i);
1055                }
1056                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1057                public TerminalNode LEADING_ASTERISK(int i) {
1058                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1059                }
1060                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1061                public TerminalNode WS(int i) {
1062                        return getToken(JavadocParser.WS, i);
1063                }
1064                public AttributeContext(ParserRuleContext parent, int invokingState) {
1065                        super(parent, invokingState);
1066                }
1067                @Override public int getRuleIndex() { return RULE_attribute; }
1068        }
1069
1070        public final AttributeContext attribute() throws RecognitionException {
1071                AttributeContext _localctx = new AttributeContext(_ctx, getState());
1072                enterRule(_localctx, 8, RULE_attribute);
1073                int _la;
1074                try {
1075                        int _alt;
1076                        enterOuterAlt(_localctx, 1);
1077                        {
1078                        setState(263);
1079                        match(HTML_TAG_NAME);
1080                        setState(267);
1081                        _errHandler.sync(this);
1082                        _la = _input.LA(1);
1083                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1084                                {
1085                                {
1086                                setState(264);
1087                                _la = _input.LA(1);
1088                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1089                                _errHandler.recoverInline(this);
1090                                }
1091                                else {
1092                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1093                                        _errHandler.reportMatch(this);
1094                                        consume();
1095                                }
1096                                }
1097                                }
1098                                setState(269);
1099                                _errHandler.sync(this);
1100                                _la = _input.LA(1);
1101                        }
1102                        setState(270);
1103                        match(EQUALS);
1104                        setState(274);
1105                        _errHandler.sync(this);
1106                        _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1107                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1108                                if ( _alt==1 ) {
1109                                        {
1110                                        {
1111                                        setState(271);
1112                                        _la = _input.LA(1);
1113                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1114                                        _errHandler.recoverInline(this);
1115                                        }
1116                                        else {
1117                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1118                                                _errHandler.reportMatch(this);
1119                                                consume();
1120                                        }
1121                                        }
1122                                        } 
1123                                }
1124                                setState(276);
1125                                _errHandler.sync(this);
1126                                _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1127                        }
1128                        setState(280);
1129                        _errHandler.sync(this);
1130                        switch (_input.LA(1)) {
1131                        case ATTR_VALUE:
1132                                {
1133                                setState(277);
1134                                match(ATTR_VALUE);
1135                                }
1136                                break;
1137                        case WS:
1138                        case CHAR:
1139                                {
1140                                setState(278);
1141                                text();
1142                                }
1143                                break;
1144                        case HTML_TAG_NAME:
1145                                {
1146                                setState(279);
1147                                match(HTML_TAG_NAME);
1148                                }
1149                                break;
1150                        default:
1151                                throw new NoViableAltException(this);
1152                        }
1153                        }
1154                }
1155                catch (RecognitionException re) {
1156                        _localctx.exception = re;
1157                        _errHandler.reportError(this, re);
1158                        _errHandler.recover(this, re);
1159                }
1160                finally {
1161                        exitRule();
1162                }
1163                return _localctx;
1164        }
1165
1166        public static class HtmlTagContext extends ParserRuleContext {
1167                public HtmlElementStartContext htmlElementStart;
1168                public HtmlElementEndContext htmlElementEnd;
1169                public HtmlElementStartContext htmlElementStart() {
1170                        return getRuleContext(HtmlElementStartContext.class,0);
1171                }
1172                public HtmlElementEndContext htmlElementEnd() {
1173                        return getRuleContext(HtmlElementEndContext.class,0);
1174                }
1175                public List<HtmlElementContext> htmlElement() {
1176                        return getRuleContexts(HtmlElementContext.class);
1177                }
1178                public HtmlElementContext htmlElement(int i) {
1179                        return getRuleContext(HtmlElementContext.class,i);
1180                }
1181                public List<HtmlCommentContext> htmlComment() {
1182                        return getRuleContexts(HtmlCommentContext.class);
1183                }
1184                public HtmlCommentContext htmlComment(int i) {
1185                        return getRuleContext(HtmlCommentContext.class,i);
1186                }
1187                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1188                public TerminalNode CDATA(int i) {
1189                        return getToken(JavadocParser.CDATA, i);
1190                }
1191                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1192                public TerminalNode NEWLINE(int i) {
1193                        return getToken(JavadocParser.NEWLINE, i);
1194                }
1195                public List<TextContext> text() {
1196                        return getRuleContexts(TextContext.class);
1197                }
1198                public TextContext text(int i) {
1199                        return getRuleContext(TextContext.class,i);
1200                }
1201                public List<JavadocInlineTagContext> javadocInlineTag() {
1202                        return getRuleContexts(JavadocInlineTagContext.class);
1203                }
1204                public JavadocInlineTagContext javadocInlineTag(int i) {
1205                        return getRuleContext(JavadocInlineTagContext.class,i);
1206                }
1207                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1208                public TerminalNode LEADING_ASTERISK(int i) {
1209                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1210                }
1211                public HtmlTagContext(ParserRuleContext parent, int invokingState) {
1212                        super(parent, invokingState);
1213                }
1214                @Override public int getRuleIndex() { return RULE_htmlTag; }
1215        }
1216
1217        public final HtmlTagContext htmlTag() throws RecognitionException {
1218                HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1219                enterRule(_localctx, 10, RULE_htmlTag);
1220                try {
1221                        int _alt;
1222                        enterOuterAlt(_localctx, 1);
1223                        {
1224                        setState(282);
1225                        ((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart();
1226                        setState(293);
1227                        _errHandler.sync(this);
1228                        _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1229                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1230                                if ( _alt==1 ) {
1231                                        {
1232                                        setState(291);
1233                                        _errHandler.sync(this);
1234                                        switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1235                                        case 1:
1236                                                {
1237                                                setState(283);
1238                                                htmlElement();
1239                                                }
1240                                                break;
1241                                        case 2:
1242                                                {
1243                                                {
1244                                                setState(284);
1245                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1246                                                setState(285);
1247                                                match(LEADING_ASTERISK);
1248                                                }
1249                                                }
1250                                                break;
1251                                        case 3:
1252                                                {
1253                                                setState(286);
1254                                                htmlComment();
1255                                                }
1256                                                break;
1257                                        case 4:
1258                                                {
1259                                                setState(287);
1260                                                match(CDATA);
1261                                                }
1262                                                break;
1263                                        case 5:
1264                                                {
1265                                                setState(288);
1266                                                match(NEWLINE);
1267                                                }
1268                                                break;
1269                                        case 6:
1270                                                {
1271                                                setState(289);
1272                                                text();
1273                                                }
1274                                                break;
1275                                        case 7:
1276                                                {
1277                                                setState(290);
1278                                                javadocInlineTag();
1279                                                }
1280                                                break;
1281                                        }
1282                                        } 
1283                                }
1284                                setState(295);
1285                                _errHandler.sync(this);
1286                                _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1287                        }
1288                        setState(296);
1289                        ((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd();
1290                        setState(297);
1291                        if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)");
1292                        }
1293                }
1294                catch (RecognitionException re) {
1295                        _localctx.exception = re;
1296                        _errHandler.reportError(this, re);
1297                        _errHandler.recover(this, re);
1298                }
1299                finally {
1300                        exitRule();
1301                }
1302                return _localctx;
1303        }
1304
1305        public static class PTagStartContext extends ParserRuleContext {
1306                public boolean isNonTight;
1307                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
1308                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1309                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
1310                public List<AttributeContext> attribute() {
1311                        return getRuleContexts(AttributeContext.class);
1312                }
1313                public AttributeContext attribute(int i) {
1314                        return getRuleContext(AttributeContext.class,i);
1315                }
1316                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1317                public TerminalNode NEWLINE(int i) {
1318                        return getToken(JavadocParser.NEWLINE, i);
1319                }
1320                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1321                public TerminalNode LEADING_ASTERISK(int i) {
1322                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1323                }
1324                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1325                public TerminalNode WS(int i) {
1326                        return getToken(JavadocParser.WS, i);
1327                }
1328                public PTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
1329                public PTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
1330                        super(parent, invokingState);
1331                        this.isNonTight = isNonTight;
1332                }
1333                @Override public int getRuleIndex() { return RULE_pTagStart; }
1334        }
1335
1336        public final PTagStartContext pTagStart(boolean isNonTight) throws RecognitionException {
1337                PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight);
1338                enterRule(_localctx, 12, RULE_pTagStart);
1339                int _la;
1340                try {
1341                        enterOuterAlt(_localctx, 1);
1342                        {
1343                        setState(299);
1344                        match(START);
1345                        setState(300);
1346                        match(P_HTML_TAG_NAME);
1347                        setState(307);
1348                        _errHandler.sync(this);
1349                        _la = _input.LA(1);
1350                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1351                                {
1352                                setState(305);
1353                                _errHandler.sync(this);
1354                                switch (_input.LA(1)) {
1355                                case HTML_TAG_NAME:
1356                                        {
1357                                        setState(301);
1358                                        attribute();
1359                                        }
1360                                        break;
1361                                case NEWLINE:
1362                                        {
1363                                        setState(302);
1364                                        match(NEWLINE);
1365                                        }
1366                                        break;
1367                                case LEADING_ASTERISK:
1368                                        {
1369                                        setState(303);
1370                                        match(LEADING_ASTERISK);
1371                                        }
1372                                        break;
1373                                case WS:
1374                                        {
1375                                        setState(304);
1376                                        match(WS);
1377                                        }
1378                                        break;
1379                                default:
1380                                        throw new NoViableAltException(this);
1381                                }
1382                                }
1383                                setState(309);
1384                                _errHandler.sync(this);
1385                                _la = _input.LA(1);
1386                        }
1387                        setState(310);
1388                        match(END);
1389                        }
1390                        _ctx.stop = _input.LT(-1);
1391
1392                            if (isNonTight && nonTightTagStartContext == null) {
1393                                nonTightTagStartContext = _localctx;
1394                            }
1395
1396                }
1397                catch (RecognitionException re) {
1398                        _localctx.exception = re;
1399                        _errHandler.reportError(this, re);
1400                        _errHandler.recover(this, re);
1401                }
1402                finally {
1403                        exitRule();
1404                }
1405                return _localctx;
1406        }
1407
1408        public static class PTagEndContext extends ParserRuleContext {
1409                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
1410                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1411                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1412                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
1413                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1414                public TerminalNode NEWLINE(int i) {
1415                        return getToken(JavadocParser.NEWLINE, i);
1416                }
1417                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1418                public TerminalNode LEADING_ASTERISK(int i) {
1419                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1420                }
1421                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1422                public TerminalNode WS(int i) {
1423                        return getToken(JavadocParser.WS, i);
1424                }
1425                public PTagEndContext(ParserRuleContext parent, int invokingState) {
1426                        super(parent, invokingState);
1427                }
1428                @Override public int getRuleIndex() { return RULE_pTagEnd; }
1429        }
1430
1431        public final PTagEndContext pTagEnd() throws RecognitionException {
1432                PTagEndContext _localctx = new PTagEndContext(_ctx, getState());
1433                enterRule(_localctx, 14, RULE_pTagEnd);
1434                int _la;
1435                try {
1436                        enterOuterAlt(_localctx, 1);
1437                        {
1438                        setState(312);
1439                        match(START);
1440                        setState(313);
1441                        match(SLASH);
1442                        setState(314);
1443                        match(P_HTML_TAG_NAME);
1444                        setState(318);
1445                        _errHandler.sync(this);
1446                        _la = _input.LA(1);
1447                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1448                                {
1449                                {
1450                                setState(315);
1451                                _la = _input.LA(1);
1452                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1453                                _errHandler.recoverInline(this);
1454                                }
1455                                else {
1456                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1457                                        _errHandler.reportMatch(this);
1458                                        consume();
1459                                }
1460                                }
1461                                }
1462                                setState(320);
1463                                _errHandler.sync(this);
1464                                _la = _input.LA(1);
1465                        }
1466                        setState(321);
1467                        match(END);
1468                        }
1469                }
1470                catch (RecognitionException re) {
1471                        _localctx.exception = re;
1472                        _errHandler.reportError(this, re);
1473                        _errHandler.recover(this, re);
1474                }
1475                finally {
1476                        exitRule();
1477                }
1478                return _localctx;
1479        }
1480
1481        public static class ParagraphContext extends ParserRuleContext {
1482                public PTagStartContext pTagStart() {
1483                        return getRuleContext(PTagStartContext.class,0);
1484                }
1485                public PTagEndContext pTagEnd() {
1486                        return getRuleContext(PTagEndContext.class,0);
1487                }
1488                public List<HtmlTagContext> htmlTag() {
1489                        return getRuleContexts(HtmlTagContext.class);
1490                }
1491                public HtmlTagContext htmlTag(int i) {
1492                        return getRuleContext(HtmlTagContext.class,i);
1493                }
1494                public List<SingletonElementContext> singletonElement() {
1495                        return getRuleContexts(SingletonElementContext.class);
1496                }
1497                public SingletonElementContext singletonElement(int i) {
1498                        return getRuleContext(SingletonElementContext.class,i);
1499                }
1500                public List<LiContext> li() {
1501                        return getRuleContexts(LiContext.class);
1502                }
1503                public LiContext li(int i) {
1504                        return getRuleContext(LiContext.class,i);
1505                }
1506                public List<TrContext> tr() {
1507                        return getRuleContexts(TrContext.class);
1508                }
1509                public TrContext tr(int i) {
1510                        return getRuleContext(TrContext.class,i);
1511                }
1512                public List<TdContext> td() {
1513                        return getRuleContexts(TdContext.class);
1514                }
1515                public TdContext td(int i) {
1516                        return getRuleContext(TdContext.class,i);
1517                }
1518                public List<ThContext> th() {
1519                        return getRuleContexts(ThContext.class);
1520                }
1521                public ThContext th(int i) {
1522                        return getRuleContext(ThContext.class,i);
1523                }
1524                public List<BodyContext> body() {
1525                        return getRuleContexts(BodyContext.class);
1526                }
1527                public BodyContext body(int i) {
1528                        return getRuleContext(BodyContext.class,i);
1529                }
1530                public List<ColgroupContext> colgroup() {
1531                        return getRuleContexts(ColgroupContext.class);
1532                }
1533                public ColgroupContext colgroup(int i) {
1534                        return getRuleContext(ColgroupContext.class,i);
1535                }
1536                public List<DdContext> dd() {
1537                        return getRuleContexts(DdContext.class);
1538                }
1539                public DdContext dd(int i) {
1540                        return getRuleContext(DdContext.class,i);
1541                }
1542                public List<DtContext> dt() {
1543                        return getRuleContexts(DtContext.class);
1544                }
1545                public DtContext dt(int i) {
1546                        return getRuleContext(DtContext.class,i);
1547                }
1548                public List<HeadContext> head() {
1549                        return getRuleContexts(HeadContext.class);
1550                }
1551                public HeadContext head(int i) {
1552                        return getRuleContext(HeadContext.class,i);
1553                }
1554                public List<HtmlContext> html() {
1555                        return getRuleContexts(HtmlContext.class);
1556                }
1557                public HtmlContext html(int i) {
1558                        return getRuleContext(HtmlContext.class,i);
1559                }
1560                public List<OptionContext> option() {
1561                        return getRuleContexts(OptionContext.class);
1562                }
1563                public OptionContext option(int i) {
1564                        return getRuleContext(OptionContext.class,i);
1565                }
1566                public List<TbodyContext> tbody() {
1567                        return getRuleContexts(TbodyContext.class);
1568                }
1569                public TbodyContext tbody(int i) {
1570                        return getRuleContext(TbodyContext.class,i);
1571                }
1572                public List<TheadContext> thead() {
1573                        return getRuleContexts(TheadContext.class);
1574                }
1575                public TheadContext thead(int i) {
1576                        return getRuleContext(TheadContext.class,i);
1577                }
1578                public List<TfootContext> tfoot() {
1579                        return getRuleContexts(TfootContext.class);
1580                }
1581                public TfootContext tfoot(int i) {
1582                        return getRuleContext(TfootContext.class,i);
1583                }
1584                public List<LiTagStartContext> liTagStart() {
1585                        return getRuleContexts(LiTagStartContext.class);
1586                }
1587                public LiTagStartContext liTagStart(int i) {
1588                        return getRuleContext(LiTagStartContext.class,i);
1589                }
1590                public List<TrTagStartContext> trTagStart() {
1591                        return getRuleContexts(TrTagStartContext.class);
1592                }
1593                public TrTagStartContext trTagStart(int i) {
1594                        return getRuleContext(TrTagStartContext.class,i);
1595                }
1596                public List<TdTagStartContext> tdTagStart() {
1597                        return getRuleContexts(TdTagStartContext.class);
1598                }
1599                public TdTagStartContext tdTagStart(int i) {
1600                        return getRuleContext(TdTagStartContext.class,i);
1601                }
1602                public List<ThTagStartContext> thTagStart() {
1603                        return getRuleContexts(ThTagStartContext.class);
1604                }
1605                public ThTagStartContext thTagStart(int i) {
1606                        return getRuleContext(ThTagStartContext.class,i);
1607                }
1608                public List<BodyTagStartContext> bodyTagStart() {
1609                        return getRuleContexts(BodyTagStartContext.class);
1610                }
1611                public BodyTagStartContext bodyTagStart(int i) {
1612                        return getRuleContext(BodyTagStartContext.class,i);
1613                }
1614                public List<ColgroupTagStartContext> colgroupTagStart() {
1615                        return getRuleContexts(ColgroupTagStartContext.class);
1616                }
1617                public ColgroupTagStartContext colgroupTagStart(int i) {
1618                        return getRuleContext(ColgroupTagStartContext.class,i);
1619                }
1620                public List<DdTagStartContext> ddTagStart() {
1621                        return getRuleContexts(DdTagStartContext.class);
1622                }
1623                public DdTagStartContext ddTagStart(int i) {
1624                        return getRuleContext(DdTagStartContext.class,i);
1625                }
1626                public List<DtTagStartContext> dtTagStart() {
1627                        return getRuleContexts(DtTagStartContext.class);
1628                }
1629                public DtTagStartContext dtTagStart(int i) {
1630                        return getRuleContext(DtTagStartContext.class,i);
1631                }
1632                public List<HeadTagStartContext> headTagStart() {
1633                        return getRuleContexts(HeadTagStartContext.class);
1634                }
1635                public HeadTagStartContext headTagStart(int i) {
1636                        return getRuleContext(HeadTagStartContext.class,i);
1637                }
1638                public List<HtmlTagStartContext> htmlTagStart() {
1639                        return getRuleContexts(HtmlTagStartContext.class);
1640                }
1641                public HtmlTagStartContext htmlTagStart(int i) {
1642                        return getRuleContext(HtmlTagStartContext.class,i);
1643                }
1644                public List<OptionTagStartContext> optionTagStart() {
1645                        return getRuleContexts(OptionTagStartContext.class);
1646                }
1647                public OptionTagStartContext optionTagStart(int i) {
1648                        return getRuleContext(OptionTagStartContext.class,i);
1649                }
1650                public List<TbodyTagStartContext> tbodyTagStart() {
1651                        return getRuleContexts(TbodyTagStartContext.class);
1652                }
1653                public TbodyTagStartContext tbodyTagStart(int i) {
1654                        return getRuleContext(TbodyTagStartContext.class,i);
1655                }
1656                public List<TheadTagStartContext> theadTagStart() {
1657                        return getRuleContexts(TheadTagStartContext.class);
1658                }
1659                public TheadTagStartContext theadTagStart(int i) {
1660                        return getRuleContext(TheadTagStartContext.class,i);
1661                }
1662                public List<TfootTagStartContext> tfootTagStart() {
1663                        return getRuleContexts(TfootTagStartContext.class);
1664                }
1665                public TfootTagStartContext tfootTagStart(int i) {
1666                        return getRuleContext(TfootTagStartContext.class,i);
1667                }
1668                public List<HtmlCommentContext> htmlComment() {
1669                        return getRuleContexts(HtmlCommentContext.class);
1670                }
1671                public HtmlCommentContext htmlComment(int i) {
1672                        return getRuleContext(HtmlCommentContext.class,i);
1673                }
1674                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1675                public TerminalNode CDATA(int i) {
1676                        return getToken(JavadocParser.CDATA, i);
1677                }
1678                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1679                public TerminalNode NEWLINE(int i) {
1680                        return getToken(JavadocParser.NEWLINE, i);
1681                }
1682                public List<TextContext> text() {
1683                        return getRuleContexts(TextContext.class);
1684                }
1685                public TextContext text(int i) {
1686                        return getRuleContext(TextContext.class,i);
1687                }
1688                public List<JavadocInlineTagContext> javadocInlineTag() {
1689                        return getRuleContexts(JavadocInlineTagContext.class);
1690                }
1691                public JavadocInlineTagContext javadocInlineTag(int i) {
1692                        return getRuleContext(JavadocInlineTagContext.class,i);
1693                }
1694                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1695                public TerminalNode LEADING_ASTERISK(int i) {
1696                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1697                }
1698                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1699                        super(parent, invokingState);
1700                }
1701                @Override public int getRuleIndex() { return RULE_paragraph; }
1702        }
1703
1704        public final ParagraphContext paragraph() throws RecognitionException {
1705                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1706                enterRule(_localctx, 16, RULE_paragraph);
1707                try {
1708                        int _alt;
1709                        enterOuterAlt(_localctx, 1);
1710                        {
1711                        setState(323);
1712                        pTagStart(false);
1713                        setState(363);
1714                        _errHandler.sync(this);
1715                        _alt = getInterpreter().adaptivePredict(_input,18,_ctx);
1716                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1717                                if ( _alt==1 ) {
1718                                        {
1719                                        setState(361);
1720                                        _errHandler.sync(this);
1721                                        switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
1722                                        case 1:
1723                                                {
1724                                                setState(324);
1725                                                htmlTag();
1726                                                }
1727                                                break;
1728                                        case 2:
1729                                                {
1730                                                setState(325);
1731                                                singletonElement();
1732                                                }
1733                                                break;
1734                                        case 3:
1735                                                {
1736                                                setState(326);
1737                                                li();
1738                                                }
1739                                                break;
1740                                        case 4:
1741                                                {
1742                                                setState(327);
1743                                                tr();
1744                                                }
1745                                                break;
1746                                        case 5:
1747                                                {
1748                                                setState(328);
1749                                                td();
1750                                                }
1751                                                break;
1752                                        case 6:
1753                                                {
1754                                                setState(329);
1755                                                th();
1756                                                }
1757                                                break;
1758                                        case 7:
1759                                                {
1760                                                setState(330);
1761                                                body();
1762                                                }
1763                                                break;
1764                                        case 8:
1765                                                {
1766                                                setState(331);
1767                                                colgroup();
1768                                                }
1769                                                break;
1770                                        case 9:
1771                                                {
1772                                                setState(332);
1773                                                dd();
1774                                                }
1775                                                break;
1776                                        case 10:
1777                                                {
1778                                                setState(333);
1779                                                dt();
1780                                                }
1781                                                break;
1782                                        case 11:
1783                                                {
1784                                                setState(334);
1785                                                head();
1786                                                }
1787                                                break;
1788                                        case 12:
1789                                                {
1790                                                setState(335);
1791                                                html();
1792                                                }
1793                                                break;
1794                                        case 13:
1795                                                {
1796                                                setState(336);
1797                                                option();
1798                                                }
1799                                                break;
1800                                        case 14:
1801                                                {
1802                                                setState(337);
1803                                                tbody();
1804                                                }
1805                                                break;
1806                                        case 15:
1807                                                {
1808                                                setState(338);
1809                                                thead();
1810                                                }
1811                                                break;
1812                                        case 16:
1813                                                {
1814                                                setState(339);
1815                                                tfoot();
1816                                                }
1817                                                break;
1818                                        case 17:
1819                                                {
1820                                                setState(340);
1821                                                liTagStart(true);
1822                                                }
1823                                                break;
1824                                        case 18:
1825                                                {
1826                                                setState(341);
1827                                                trTagStart(true);
1828                                                }
1829                                                break;
1830                                        case 19:
1831                                                {
1832                                                setState(342);
1833                                                tdTagStart(true);
1834                                                }
1835                                                break;
1836                                        case 20:
1837                                                {
1838                                                setState(343);
1839                                                thTagStart(true);
1840                                                }
1841                                                break;
1842                                        case 21:
1843                                                {
1844                                                setState(344);
1845                                                bodyTagStart(true);
1846                                                }
1847                                                break;
1848                                        case 22:
1849                                                {
1850                                                setState(345);
1851                                                colgroupTagStart(true);
1852                                                }
1853                                                break;
1854                                        case 23:
1855                                                {
1856                                                setState(346);
1857                                                ddTagStart(true);
1858                                                }
1859                                                break;
1860                                        case 24:
1861                                                {
1862                                                setState(347);
1863                                                dtTagStart(true);
1864                                                }
1865                                                break;
1866                                        case 25:
1867                                                {
1868                                                setState(348);
1869                                                headTagStart(true);
1870                                                }
1871                                                break;
1872                                        case 26:
1873                                                {
1874                                                setState(349);
1875                                                htmlTagStart(true);
1876                                                }
1877                                                break;
1878                                        case 27:
1879                                                {
1880                                                setState(350);
1881                                                optionTagStart(true);
1882                                                }
1883                                                break;
1884                                        case 28:
1885                                                {
1886                                                setState(351);
1887                                                tbodyTagStart(true);
1888                                                }
1889                                                break;
1890                                        case 29:
1891                                                {
1892                                                setState(352);
1893                                                theadTagStart(true);
1894                                                }
1895                                                break;
1896                                        case 30:
1897                                                {
1898                                                setState(353);
1899                                                tfootTagStart(true);
1900                                                }
1901                                                break;
1902                                        case 31:
1903                                                {
1904                                                {
1905                                                setState(354);
1906                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1907                                                setState(355);
1908                                                match(LEADING_ASTERISK);
1909                                                }
1910                                                }
1911                                                break;
1912                                        case 32:
1913                                                {
1914                                                setState(356);
1915                                                htmlComment();
1916                                                }
1917                                                break;
1918                                        case 33:
1919                                                {
1920                                                setState(357);
1921                                                match(CDATA);
1922                                                }
1923                                                break;
1924                                        case 34:
1925                                                {
1926                                                setState(358);
1927                                                match(NEWLINE);
1928                                                }
1929                                                break;
1930                                        case 35:
1931                                                {
1932                                                setState(359);
1933                                                text();
1934                                                }
1935                                                break;
1936                                        case 36:
1937                                                {
1938                                                setState(360);
1939                                                javadocInlineTag();
1940                                                }
1941                                                break;
1942                                        }
1943                                        } 
1944                                }
1945                                setState(365);
1946                                _errHandler.sync(this);
1947                                _alt = getInterpreter().adaptivePredict(_input,18,_ctx);
1948                        }
1949                        setState(366);
1950                        pTagEnd();
1951                        }
1952                }
1953                catch (RecognitionException re) {
1954                        _localctx.exception = re;
1955                        _errHandler.reportError(this, re);
1956                        _errHandler.recover(this, re);
1957                }
1958                finally {
1959                        exitRule();
1960                }
1961                return _localctx;
1962        }
1963
1964        public static class LiTagStartContext extends ParserRuleContext {
1965                public boolean isNonTight;
1966                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
1967                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
1968                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
1969                public List<AttributeContext> attribute() {
1970                        return getRuleContexts(AttributeContext.class);
1971                }
1972                public AttributeContext attribute(int i) {
1973                        return getRuleContext(AttributeContext.class,i);
1974                }
1975                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1976                public TerminalNode NEWLINE(int i) {
1977                        return getToken(JavadocParser.NEWLINE, i);
1978                }
1979                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1980                public TerminalNode LEADING_ASTERISK(int i) {
1981                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1982                }
1983                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1984                public TerminalNode WS(int i) {
1985                        return getToken(JavadocParser.WS, i);
1986                }
1987                public LiTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
1988                public LiTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
1989                        super(parent, invokingState);
1990                        this.isNonTight = isNonTight;
1991                }
1992                @Override public int getRuleIndex() { return RULE_liTagStart; }
1993        }
1994
1995        public final LiTagStartContext liTagStart(boolean isNonTight) throws RecognitionException {
1996                LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight);
1997                enterRule(_localctx, 18, RULE_liTagStart);
1998                int _la;
1999                try {
2000                        enterOuterAlt(_localctx, 1);
2001                        {
2002                        setState(368);
2003                        match(START);
2004                        setState(369);
2005                        match(LI_HTML_TAG_NAME);
2006                        setState(376);
2007                        _errHandler.sync(this);
2008                        _la = _input.LA(1);
2009                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2010                                {
2011                                setState(374);
2012                                _errHandler.sync(this);
2013                                switch (_input.LA(1)) {
2014                                case HTML_TAG_NAME:
2015                                        {
2016                                        setState(370);
2017                                        attribute();
2018                                        }
2019                                        break;
2020                                case NEWLINE:
2021                                        {
2022                                        setState(371);
2023                                        match(NEWLINE);
2024                                        }
2025                                        break;
2026                                case LEADING_ASTERISK:
2027                                        {
2028                                        setState(372);
2029                                        match(LEADING_ASTERISK);
2030                                        }
2031                                        break;
2032                                case WS:
2033                                        {
2034                                        setState(373);
2035                                        match(WS);
2036                                        }
2037                                        break;
2038                                default:
2039                                        throw new NoViableAltException(this);
2040                                }
2041                                }
2042                                setState(378);
2043                                _errHandler.sync(this);
2044                                _la = _input.LA(1);
2045                        }
2046                        setState(379);
2047                        match(END);
2048                        }
2049                        _ctx.stop = _input.LT(-1);
2050
2051                            if (isNonTight && nonTightTagStartContext == null) {
2052                                nonTightTagStartContext = _localctx;
2053                            }
2054
2055                }
2056                catch (RecognitionException re) {
2057                        _localctx.exception = re;
2058                        _errHandler.reportError(this, re);
2059                        _errHandler.recover(this, re);
2060                }
2061                finally {
2062                        exitRule();
2063                }
2064                return _localctx;
2065        }
2066
2067        public static class LiTagEndContext extends ParserRuleContext {
2068                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
2069                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2070                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2071                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
2072                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2073                public TerminalNode NEWLINE(int i) {
2074                        return getToken(JavadocParser.NEWLINE, i);
2075                }
2076                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2077                public TerminalNode LEADING_ASTERISK(int i) {
2078                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2079                }
2080                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2081                public TerminalNode WS(int i) {
2082                        return getToken(JavadocParser.WS, i);
2083                }
2084                public LiTagEndContext(ParserRuleContext parent, int invokingState) {
2085                        super(parent, invokingState);
2086                }
2087                @Override public int getRuleIndex() { return RULE_liTagEnd; }
2088        }
2089
2090        public final LiTagEndContext liTagEnd() throws RecognitionException {
2091                LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState());
2092                enterRule(_localctx, 20, RULE_liTagEnd);
2093                int _la;
2094                try {
2095                        enterOuterAlt(_localctx, 1);
2096                        {
2097                        setState(381);
2098                        match(START);
2099                        setState(382);
2100                        match(SLASH);
2101                        setState(383);
2102                        match(LI_HTML_TAG_NAME);
2103                        setState(387);
2104                        _errHandler.sync(this);
2105                        _la = _input.LA(1);
2106                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2107                                {
2108                                {
2109                                setState(384);
2110                                _la = _input.LA(1);
2111                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2112                                _errHandler.recoverInline(this);
2113                                }
2114                                else {
2115                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
2116                                        _errHandler.reportMatch(this);
2117                                        consume();
2118                                }
2119                                }
2120                                }
2121                                setState(389);
2122                                _errHandler.sync(this);
2123                                _la = _input.LA(1);
2124                        }
2125                        setState(390);
2126                        match(END);
2127                        }
2128                }
2129                catch (RecognitionException re) {
2130                        _localctx.exception = re;
2131                        _errHandler.reportError(this, re);
2132                        _errHandler.recover(this, re);
2133                }
2134                finally {
2135                        exitRule();
2136                }
2137                return _localctx;
2138        }
2139
2140        public static class LiContext extends ParserRuleContext {
2141                public LiTagStartContext liTagStart() {
2142                        return getRuleContext(LiTagStartContext.class,0);
2143                }
2144                public LiTagEndContext liTagEnd() {
2145                        return getRuleContext(LiTagEndContext.class,0);
2146                }
2147                public List<HtmlTagContext> htmlTag() {
2148                        return getRuleContexts(HtmlTagContext.class);
2149                }
2150                public HtmlTagContext htmlTag(int i) {
2151                        return getRuleContext(HtmlTagContext.class,i);
2152                }
2153                public List<SingletonElementContext> singletonElement() {
2154                        return getRuleContexts(SingletonElementContext.class);
2155                }
2156                public SingletonElementContext singletonElement(int i) {
2157                        return getRuleContext(SingletonElementContext.class,i);
2158                }
2159                public List<ParagraphContext> paragraph() {
2160                        return getRuleContexts(ParagraphContext.class);
2161                }
2162                public ParagraphContext paragraph(int i) {
2163                        return getRuleContext(ParagraphContext.class,i);
2164                }
2165                public List<TrContext> tr() {
2166                        return getRuleContexts(TrContext.class);
2167                }
2168                public TrContext tr(int i) {
2169                        return getRuleContext(TrContext.class,i);
2170                }
2171                public List<TdContext> td() {
2172                        return getRuleContexts(TdContext.class);
2173                }
2174                public TdContext td(int i) {
2175                        return getRuleContext(TdContext.class,i);
2176                }
2177                public List<ThContext> th() {
2178                        return getRuleContexts(ThContext.class);
2179                }
2180                public ThContext th(int i) {
2181                        return getRuleContext(ThContext.class,i);
2182                }
2183                public List<BodyContext> body() {
2184                        return getRuleContexts(BodyContext.class);
2185                }
2186                public BodyContext body(int i) {
2187                        return getRuleContext(BodyContext.class,i);
2188                }
2189                public List<ColgroupContext> colgroup() {
2190                        return getRuleContexts(ColgroupContext.class);
2191                }
2192                public ColgroupContext colgroup(int i) {
2193                        return getRuleContext(ColgroupContext.class,i);
2194                }
2195                public List<DdContext> dd() {
2196                        return getRuleContexts(DdContext.class);
2197                }
2198                public DdContext dd(int i) {
2199                        return getRuleContext(DdContext.class,i);
2200                }
2201                public List<DtContext> dt() {
2202                        return getRuleContexts(DtContext.class);
2203                }
2204                public DtContext dt(int i) {
2205                        return getRuleContext(DtContext.class,i);
2206                }
2207                public List<HeadContext> head() {
2208                        return getRuleContexts(HeadContext.class);
2209                }
2210                public HeadContext head(int i) {
2211                        return getRuleContext(HeadContext.class,i);
2212                }
2213                public List<HtmlContext> html() {
2214                        return getRuleContexts(HtmlContext.class);
2215                }
2216                public HtmlContext html(int i) {
2217                        return getRuleContext(HtmlContext.class,i);
2218                }
2219                public List<OptionContext> option() {
2220                        return getRuleContexts(OptionContext.class);
2221                }
2222                public OptionContext option(int i) {
2223                        return getRuleContext(OptionContext.class,i);
2224                }
2225                public List<TbodyContext> tbody() {
2226                        return getRuleContexts(TbodyContext.class);
2227                }
2228                public TbodyContext tbody(int i) {
2229                        return getRuleContext(TbodyContext.class,i);
2230                }
2231                public List<TheadContext> thead() {
2232                        return getRuleContexts(TheadContext.class);
2233                }
2234                public TheadContext thead(int i) {
2235                        return getRuleContext(TheadContext.class,i);
2236                }
2237                public List<TfootContext> tfoot() {
2238                        return getRuleContexts(TfootContext.class);
2239                }
2240                public TfootContext tfoot(int i) {
2241                        return getRuleContext(TfootContext.class,i);
2242                }
2243                public List<PTagStartContext> pTagStart() {
2244                        return getRuleContexts(PTagStartContext.class);
2245                }
2246                public PTagStartContext pTagStart(int i) {
2247                        return getRuleContext(PTagStartContext.class,i);
2248                }
2249                public List<TrTagStartContext> trTagStart() {
2250                        return getRuleContexts(TrTagStartContext.class);
2251                }
2252                public TrTagStartContext trTagStart(int i) {
2253                        return getRuleContext(TrTagStartContext.class,i);
2254                }
2255                public List<TdTagStartContext> tdTagStart() {
2256                        return getRuleContexts(TdTagStartContext.class);
2257                }
2258                public TdTagStartContext tdTagStart(int i) {
2259                        return getRuleContext(TdTagStartContext.class,i);
2260                }
2261                public List<ThTagStartContext> thTagStart() {
2262                        return getRuleContexts(ThTagStartContext.class);
2263                }
2264                public ThTagStartContext thTagStart(int i) {
2265                        return getRuleContext(ThTagStartContext.class,i);
2266                }
2267                public List<BodyTagStartContext> bodyTagStart() {
2268                        return getRuleContexts(BodyTagStartContext.class);
2269                }
2270                public BodyTagStartContext bodyTagStart(int i) {
2271                        return getRuleContext(BodyTagStartContext.class,i);
2272                }
2273                public List<ColgroupTagStartContext> colgroupTagStart() {
2274                        return getRuleContexts(ColgroupTagStartContext.class);
2275                }
2276                public ColgroupTagStartContext colgroupTagStart(int i) {
2277                        return getRuleContext(ColgroupTagStartContext.class,i);
2278                }
2279                public List<DdTagStartContext> ddTagStart() {
2280                        return getRuleContexts(DdTagStartContext.class);
2281                }
2282                public DdTagStartContext ddTagStart(int i) {
2283                        return getRuleContext(DdTagStartContext.class,i);
2284                }
2285                public List<DtTagStartContext> dtTagStart() {
2286                        return getRuleContexts(DtTagStartContext.class);
2287                }
2288                public DtTagStartContext dtTagStart(int i) {
2289                        return getRuleContext(DtTagStartContext.class,i);
2290                }
2291                public List<HeadTagStartContext> headTagStart() {
2292                        return getRuleContexts(HeadTagStartContext.class);
2293                }
2294                public HeadTagStartContext headTagStart(int i) {
2295                        return getRuleContext(HeadTagStartContext.class,i);
2296                }
2297                public List<HtmlTagStartContext> htmlTagStart() {
2298                        return getRuleContexts(HtmlTagStartContext.class);
2299                }
2300                public HtmlTagStartContext htmlTagStart(int i) {
2301                        return getRuleContext(HtmlTagStartContext.class,i);
2302                }
2303                public List<OptionTagStartContext> optionTagStart() {
2304                        return getRuleContexts(OptionTagStartContext.class);
2305                }
2306                public OptionTagStartContext optionTagStart(int i) {
2307                        return getRuleContext(OptionTagStartContext.class,i);
2308                }
2309                public List<TbodyTagStartContext> tbodyTagStart() {
2310                        return getRuleContexts(TbodyTagStartContext.class);
2311                }
2312                public TbodyTagStartContext tbodyTagStart(int i) {
2313                        return getRuleContext(TbodyTagStartContext.class,i);
2314                }
2315                public List<TheadTagStartContext> theadTagStart() {
2316                        return getRuleContexts(TheadTagStartContext.class);
2317                }
2318                public TheadTagStartContext theadTagStart(int i) {
2319                        return getRuleContext(TheadTagStartContext.class,i);
2320                }
2321                public List<TfootTagStartContext> tfootTagStart() {
2322                        return getRuleContexts(TfootTagStartContext.class);
2323                }
2324                public TfootTagStartContext tfootTagStart(int i) {
2325                        return getRuleContext(TfootTagStartContext.class,i);
2326                }
2327                public List<HtmlCommentContext> htmlComment() {
2328                        return getRuleContexts(HtmlCommentContext.class);
2329                }
2330                public HtmlCommentContext htmlComment(int i) {
2331                        return getRuleContext(HtmlCommentContext.class,i);
2332                }
2333                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2334                public TerminalNode CDATA(int i) {
2335                        return getToken(JavadocParser.CDATA, i);
2336                }
2337                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2338                public TerminalNode NEWLINE(int i) {
2339                        return getToken(JavadocParser.NEWLINE, i);
2340                }
2341                public List<TextContext> text() {
2342                        return getRuleContexts(TextContext.class);
2343                }
2344                public TextContext text(int i) {
2345                        return getRuleContext(TextContext.class,i);
2346                }
2347                public List<JavadocInlineTagContext> javadocInlineTag() {
2348                        return getRuleContexts(JavadocInlineTagContext.class);
2349                }
2350                public JavadocInlineTagContext javadocInlineTag(int i) {
2351                        return getRuleContext(JavadocInlineTagContext.class,i);
2352                }
2353                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2354                public TerminalNode LEADING_ASTERISK(int i) {
2355                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2356                }
2357                public LiContext(ParserRuleContext parent, int invokingState) {
2358                        super(parent, invokingState);
2359                }
2360                @Override public int getRuleIndex() { return RULE_li; }
2361        }
2362
2363        public final LiContext li() throws RecognitionException {
2364                LiContext _localctx = new LiContext(_ctx, getState());
2365                enterRule(_localctx, 22, RULE_li);
2366                try {
2367                        int _alt;
2368                        enterOuterAlt(_localctx, 1);
2369                        {
2370                        setState(392);
2371                        liTagStart(false);
2372                        setState(432);
2373                        _errHandler.sync(this);
2374                        _alt = getInterpreter().adaptivePredict(_input,23,_ctx);
2375                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2376                                if ( _alt==1 ) {
2377                                        {
2378                                        setState(430);
2379                                        _errHandler.sync(this);
2380                                        switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
2381                                        case 1:
2382                                                {
2383                                                setState(393);
2384                                                htmlTag();
2385                                                }
2386                                                break;
2387                                        case 2:
2388                                                {
2389                                                setState(394);
2390                                                singletonElement();
2391                                                }
2392                                                break;
2393                                        case 3:
2394                                                {
2395                                                setState(395);
2396                                                paragraph();
2397                                                }
2398                                                break;
2399                                        case 4:
2400                                                {
2401                                                setState(396);
2402                                                tr();
2403                                                }
2404                                                break;
2405                                        case 5:
2406                                                {
2407                                                setState(397);
2408                                                td();
2409                                                }
2410                                                break;
2411                                        case 6:
2412                                                {
2413                                                setState(398);
2414                                                th();
2415                                                }
2416                                                break;
2417                                        case 7:
2418                                                {
2419                                                setState(399);
2420                                                body();
2421                                                }
2422                                                break;
2423                                        case 8:
2424                                                {
2425                                                setState(400);
2426                                                colgroup();
2427                                                }
2428                                                break;
2429                                        case 9:
2430                                                {
2431                                                setState(401);
2432                                                dd();
2433                                                }
2434                                                break;
2435                                        case 10:
2436                                                {
2437                                                setState(402);
2438                                                dt();
2439                                                }
2440                                                break;
2441                                        case 11:
2442                                                {
2443                                                setState(403);
2444                                                head();
2445                                                }
2446                                                break;
2447                                        case 12:
2448                                                {
2449                                                setState(404);
2450                                                html();
2451                                                }
2452                                                break;
2453                                        case 13:
2454                                                {
2455                                                setState(405);
2456                                                option();
2457                                                }
2458                                                break;
2459                                        case 14:
2460                                                {
2461                                                setState(406);
2462                                                tbody();
2463                                                }
2464                                                break;
2465                                        case 15:
2466                                                {
2467                                                setState(407);
2468                                                thead();
2469                                                }
2470                                                break;
2471                                        case 16:
2472                                                {
2473                                                setState(408);
2474                                                tfoot();
2475                                                }
2476                                                break;
2477                                        case 17:
2478                                                {
2479                                                setState(409);
2480                                                pTagStart(true);
2481                                                }
2482                                                break;
2483                                        case 18:
2484                                                {
2485                                                setState(410);
2486                                                trTagStart(true);
2487                                                }
2488                                                break;
2489                                        case 19:
2490                                                {
2491                                                setState(411);
2492                                                tdTagStart(true);
2493                                                }
2494                                                break;
2495                                        case 20:
2496                                                {
2497                                                setState(412);
2498                                                thTagStart(true);
2499                                                }
2500                                                break;
2501                                        case 21:
2502                                                {
2503                                                setState(413);
2504                                                bodyTagStart(true);
2505                                                }
2506                                                break;
2507                                        case 22:
2508                                                {
2509                                                setState(414);
2510                                                colgroupTagStart(true);
2511                                                }
2512                                                break;
2513                                        case 23:
2514                                                {
2515                                                setState(415);
2516                                                ddTagStart(true);
2517                                                }
2518                                                break;
2519                                        case 24:
2520                                                {
2521                                                setState(416);
2522                                                dtTagStart(true);
2523                                                }
2524                                                break;
2525                                        case 25:
2526                                                {
2527                                                setState(417);
2528                                                headTagStart(true);
2529                                                }
2530                                                break;
2531                                        case 26:
2532                                                {
2533                                                setState(418);
2534                                                htmlTagStart(true);
2535                                                }
2536                                                break;
2537                                        case 27:
2538                                                {
2539                                                setState(419);
2540                                                optionTagStart(true);
2541                                                }
2542                                                break;
2543                                        case 28:
2544                                                {
2545                                                setState(420);
2546                                                tbodyTagStart(true);
2547                                                }
2548                                                break;
2549                                        case 29:
2550                                                {
2551                                                setState(421);
2552                                                theadTagStart(true);
2553                                                }
2554                                                break;
2555                                        case 30:
2556                                                {
2557                                                setState(422);
2558                                                tfootTagStart(true);
2559                                                }
2560                                                break;
2561                                        case 31:
2562                                                {
2563                                                {
2564                                                setState(423);
2565                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2566                                                setState(424);
2567                                                match(LEADING_ASTERISK);
2568                                                }
2569                                                }
2570                                                break;
2571                                        case 32:
2572                                                {
2573                                                setState(425);
2574                                                htmlComment();
2575                                                }
2576                                                break;
2577                                        case 33:
2578                                                {
2579                                                setState(426);
2580                                                match(CDATA);
2581                                                }
2582                                                break;
2583                                        case 34:
2584                                                {
2585                                                setState(427);
2586                                                match(NEWLINE);
2587                                                }
2588                                                break;
2589                                        case 35:
2590                                                {
2591                                                setState(428);
2592                                                text();
2593                                                }
2594                                                break;
2595                                        case 36:
2596                                                {
2597                                                setState(429);
2598                                                javadocInlineTag();
2599                                                }
2600                                                break;
2601                                        }
2602                                        } 
2603                                }
2604                                setState(434);
2605                                _errHandler.sync(this);
2606                                _alt = getInterpreter().adaptivePredict(_input,23,_ctx);
2607                        }
2608                        setState(435);
2609                        liTagEnd();
2610                        }
2611                }
2612                catch (RecognitionException re) {
2613                        _localctx.exception = re;
2614                        _errHandler.reportError(this, re);
2615                        _errHandler.recover(this, re);
2616                }
2617                finally {
2618                        exitRule();
2619                }
2620                return _localctx;
2621        }
2622
2623        public static class TrTagStartContext extends ParserRuleContext {
2624                public boolean isNonTight;
2625                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
2626                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2627                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
2628                public List<AttributeContext> attribute() {
2629                        return getRuleContexts(AttributeContext.class);
2630                }
2631                public AttributeContext attribute(int i) {
2632                        return getRuleContext(AttributeContext.class,i);
2633                }
2634                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2635                public TerminalNode NEWLINE(int i) {
2636                        return getToken(JavadocParser.NEWLINE, i);
2637                }
2638                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2639                public TerminalNode LEADING_ASTERISK(int i) {
2640                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2641                }
2642                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2643                public TerminalNode WS(int i) {
2644                        return getToken(JavadocParser.WS, i);
2645                }
2646                public TrTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
2647                public TrTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
2648                        super(parent, invokingState);
2649                        this.isNonTight = isNonTight;
2650                }
2651                @Override public int getRuleIndex() { return RULE_trTagStart; }
2652        }
2653
2654        public final TrTagStartContext trTagStart(boolean isNonTight) throws RecognitionException {
2655                TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight);
2656                enterRule(_localctx, 24, RULE_trTagStart);
2657                int _la;
2658                try {
2659                        enterOuterAlt(_localctx, 1);
2660                        {
2661                        setState(437);
2662                        match(START);
2663                        setState(438);
2664                        match(TR_HTML_TAG_NAME);
2665                        setState(445);
2666                        _errHandler.sync(this);
2667                        _la = _input.LA(1);
2668                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2669                                {
2670                                setState(443);
2671                                _errHandler.sync(this);
2672                                switch (_input.LA(1)) {
2673                                case HTML_TAG_NAME:
2674                                        {
2675                                        setState(439);
2676                                        attribute();
2677                                        }
2678                                        break;
2679                                case NEWLINE:
2680                                        {
2681                                        setState(440);
2682                                        match(NEWLINE);
2683                                        }
2684                                        break;
2685                                case LEADING_ASTERISK:
2686                                        {
2687                                        setState(441);
2688                                        match(LEADING_ASTERISK);
2689                                        }
2690                                        break;
2691                                case WS:
2692                                        {
2693                                        setState(442);
2694                                        match(WS);
2695                                        }
2696                                        break;
2697                                default:
2698                                        throw new NoViableAltException(this);
2699                                }
2700                                }
2701                                setState(447);
2702                                _errHandler.sync(this);
2703                                _la = _input.LA(1);
2704                        }
2705                        setState(448);
2706                        match(END);
2707                        }
2708                        _ctx.stop = _input.LT(-1);
2709
2710                            if (isNonTight && nonTightTagStartContext == null) {
2711                                nonTightTagStartContext = _localctx;
2712                            }
2713
2714                }
2715                catch (RecognitionException re) {
2716                        _localctx.exception = re;
2717                        _errHandler.reportError(this, re);
2718                        _errHandler.recover(this, re);
2719                }
2720                finally {
2721                        exitRule();
2722                }
2723                return _localctx;
2724        }
2725
2726        public static class TrTagEndContext extends ParserRuleContext {
2727                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
2728                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2729                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2730                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
2731                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2732                public TerminalNode NEWLINE(int i) {
2733                        return getToken(JavadocParser.NEWLINE, i);
2734                }
2735                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2736                public TerminalNode LEADING_ASTERISK(int i) {
2737                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2738                }
2739                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2740                public TerminalNode WS(int i) {
2741                        return getToken(JavadocParser.WS, i);
2742                }
2743                public TrTagEndContext(ParserRuleContext parent, int invokingState) {
2744                        super(parent, invokingState);
2745                }
2746                @Override public int getRuleIndex() { return RULE_trTagEnd; }
2747        }
2748
2749        public final TrTagEndContext trTagEnd() throws RecognitionException {
2750                TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState());
2751                enterRule(_localctx, 26, RULE_trTagEnd);
2752                int _la;
2753                try {
2754                        enterOuterAlt(_localctx, 1);
2755                        {
2756                        setState(450);
2757                        match(START);
2758                        setState(451);
2759                        match(SLASH);
2760                        setState(452);
2761                        match(TR_HTML_TAG_NAME);
2762                        setState(456);
2763                        _errHandler.sync(this);
2764                        _la = _input.LA(1);
2765                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2766                                {
2767                                {
2768                                setState(453);
2769                                _la = _input.LA(1);
2770                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2771                                _errHandler.recoverInline(this);
2772                                }
2773                                else {
2774                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
2775                                        _errHandler.reportMatch(this);
2776                                        consume();
2777                                }
2778                                }
2779                                }
2780                                setState(458);
2781                                _errHandler.sync(this);
2782                                _la = _input.LA(1);
2783                        }
2784                        setState(459);
2785                        match(END);
2786                        }
2787                }
2788                catch (RecognitionException re) {
2789                        _localctx.exception = re;
2790                        _errHandler.reportError(this, re);
2791                        _errHandler.recover(this, re);
2792                }
2793                finally {
2794                        exitRule();
2795                }
2796                return _localctx;
2797        }
2798
2799        public static class TrContext extends ParserRuleContext {
2800                public TrTagStartContext trTagStart() {
2801                        return getRuleContext(TrTagStartContext.class,0);
2802                }
2803                public TrTagEndContext trTagEnd() {
2804                        return getRuleContext(TrTagEndContext.class,0);
2805                }
2806                public List<HtmlTagContext> htmlTag() {
2807                        return getRuleContexts(HtmlTagContext.class);
2808                }
2809                public HtmlTagContext htmlTag(int i) {
2810                        return getRuleContext(HtmlTagContext.class,i);
2811                }
2812                public List<SingletonElementContext> singletonElement() {
2813                        return getRuleContexts(SingletonElementContext.class);
2814                }
2815                public SingletonElementContext singletonElement(int i) {
2816                        return getRuleContext(SingletonElementContext.class,i);
2817                }
2818                public List<ParagraphContext> paragraph() {
2819                        return getRuleContexts(ParagraphContext.class);
2820                }
2821                public ParagraphContext paragraph(int i) {
2822                        return getRuleContext(ParagraphContext.class,i);
2823                }
2824                public List<LiContext> li() {
2825                        return getRuleContexts(LiContext.class);
2826                }
2827                public LiContext li(int i) {
2828                        return getRuleContext(LiContext.class,i);
2829                }
2830                public List<TdContext> td() {
2831                        return getRuleContexts(TdContext.class);
2832                }
2833                public TdContext td(int i) {
2834                        return getRuleContext(TdContext.class,i);
2835                }
2836                public List<ThContext> th() {
2837                        return getRuleContexts(ThContext.class);
2838                }
2839                public ThContext th(int i) {
2840                        return getRuleContext(ThContext.class,i);
2841                }
2842                public List<BodyContext> body() {
2843                        return getRuleContexts(BodyContext.class);
2844                }
2845                public BodyContext body(int i) {
2846                        return getRuleContext(BodyContext.class,i);
2847                }
2848                public List<ColgroupContext> colgroup() {
2849                        return getRuleContexts(ColgroupContext.class);
2850                }
2851                public ColgroupContext colgroup(int i) {
2852                        return getRuleContext(ColgroupContext.class,i);
2853                }
2854                public List<DdContext> dd() {
2855                        return getRuleContexts(DdContext.class);
2856                }
2857                public DdContext dd(int i) {
2858                        return getRuleContext(DdContext.class,i);
2859                }
2860                public List<DtContext> dt() {
2861                        return getRuleContexts(DtContext.class);
2862                }
2863                public DtContext dt(int i) {
2864                        return getRuleContext(DtContext.class,i);
2865                }
2866                public List<HeadContext> head() {
2867                        return getRuleContexts(HeadContext.class);
2868                }
2869                public HeadContext head(int i) {
2870                        return getRuleContext(HeadContext.class,i);
2871                }
2872                public List<HtmlContext> html() {
2873                        return getRuleContexts(HtmlContext.class);
2874                }
2875                public HtmlContext html(int i) {
2876                        return getRuleContext(HtmlContext.class,i);
2877                }
2878                public List<OptionContext> option() {
2879                        return getRuleContexts(OptionContext.class);
2880                }
2881                public OptionContext option(int i) {
2882                        return getRuleContext(OptionContext.class,i);
2883                }
2884                public List<TbodyContext> tbody() {
2885                        return getRuleContexts(TbodyContext.class);
2886                }
2887                public TbodyContext tbody(int i) {
2888                        return getRuleContext(TbodyContext.class,i);
2889                }
2890                public List<TheadContext> thead() {
2891                        return getRuleContexts(TheadContext.class);
2892                }
2893                public TheadContext thead(int i) {
2894                        return getRuleContext(TheadContext.class,i);
2895                }
2896                public List<TfootContext> tfoot() {
2897                        return getRuleContexts(TfootContext.class);
2898                }
2899                public TfootContext tfoot(int i) {
2900                        return getRuleContext(TfootContext.class,i);
2901                }
2902                public List<PTagStartContext> pTagStart() {
2903                        return getRuleContexts(PTagStartContext.class);
2904                }
2905                public PTagStartContext pTagStart(int i) {
2906                        return getRuleContext(PTagStartContext.class,i);
2907                }
2908                public List<LiTagStartContext> liTagStart() {
2909                        return getRuleContexts(LiTagStartContext.class);
2910                }
2911                public LiTagStartContext liTagStart(int i) {
2912                        return getRuleContext(LiTagStartContext.class,i);
2913                }
2914                public List<TdTagStartContext> tdTagStart() {
2915                        return getRuleContexts(TdTagStartContext.class);
2916                }
2917                public TdTagStartContext tdTagStart(int i) {
2918                        return getRuleContext(TdTagStartContext.class,i);
2919                }
2920                public List<ThTagStartContext> thTagStart() {
2921                        return getRuleContexts(ThTagStartContext.class);
2922                }
2923                public ThTagStartContext thTagStart(int i) {
2924                        return getRuleContext(ThTagStartContext.class,i);
2925                }
2926                public List<BodyTagStartContext> bodyTagStart() {
2927                        return getRuleContexts(BodyTagStartContext.class);
2928                }
2929                public BodyTagStartContext bodyTagStart(int i) {
2930                        return getRuleContext(BodyTagStartContext.class,i);
2931                }
2932                public List<ColgroupTagStartContext> colgroupTagStart() {
2933                        return getRuleContexts(ColgroupTagStartContext.class);
2934                }
2935                public ColgroupTagStartContext colgroupTagStart(int i) {
2936                        return getRuleContext(ColgroupTagStartContext.class,i);
2937                }
2938                public List<DdTagStartContext> ddTagStart() {
2939                        return getRuleContexts(DdTagStartContext.class);
2940                }
2941                public DdTagStartContext ddTagStart(int i) {
2942                        return getRuleContext(DdTagStartContext.class,i);
2943                }
2944                public List<DtTagStartContext> dtTagStart() {
2945                        return getRuleContexts(DtTagStartContext.class);
2946                }
2947                public DtTagStartContext dtTagStart(int i) {
2948                        return getRuleContext(DtTagStartContext.class,i);
2949                }
2950                public List<HeadTagStartContext> headTagStart() {
2951                        return getRuleContexts(HeadTagStartContext.class);
2952                }
2953                public HeadTagStartContext headTagStart(int i) {
2954                        return getRuleContext(HeadTagStartContext.class,i);
2955                }
2956                public List<HtmlTagStartContext> htmlTagStart() {
2957                        return getRuleContexts(HtmlTagStartContext.class);
2958                }
2959                public HtmlTagStartContext htmlTagStart(int i) {
2960                        return getRuleContext(HtmlTagStartContext.class,i);
2961                }
2962                public List<OptionTagStartContext> optionTagStart() {
2963                        return getRuleContexts(OptionTagStartContext.class);
2964                }
2965                public OptionTagStartContext optionTagStart(int i) {
2966                        return getRuleContext(OptionTagStartContext.class,i);
2967                }
2968                public List<TbodyTagStartContext> tbodyTagStart() {
2969                        return getRuleContexts(TbodyTagStartContext.class);
2970                }
2971                public TbodyTagStartContext tbodyTagStart(int i) {
2972                        return getRuleContext(TbodyTagStartContext.class,i);
2973                }
2974                public List<TheadTagStartContext> theadTagStart() {
2975                        return getRuleContexts(TheadTagStartContext.class);
2976                }
2977                public TheadTagStartContext theadTagStart(int i) {
2978                        return getRuleContext(TheadTagStartContext.class,i);
2979                }
2980                public List<TfootTagStartContext> tfootTagStart() {
2981                        return getRuleContexts(TfootTagStartContext.class);
2982                }
2983                public TfootTagStartContext tfootTagStart(int i) {
2984                        return getRuleContext(TfootTagStartContext.class,i);
2985                }
2986                public List<HtmlCommentContext> htmlComment() {
2987                        return getRuleContexts(HtmlCommentContext.class);
2988                }
2989                public HtmlCommentContext htmlComment(int i) {
2990                        return getRuleContext(HtmlCommentContext.class,i);
2991                }
2992                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2993                public TerminalNode CDATA(int i) {
2994                        return getToken(JavadocParser.CDATA, i);
2995                }
2996                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2997                public TerminalNode NEWLINE(int i) {
2998                        return getToken(JavadocParser.NEWLINE, i);
2999                }
3000                public List<TextContext> text() {
3001                        return getRuleContexts(TextContext.class);
3002                }
3003                public TextContext text(int i) {
3004                        return getRuleContext(TextContext.class,i);
3005                }
3006                public List<JavadocInlineTagContext> javadocInlineTag() {
3007                        return getRuleContexts(JavadocInlineTagContext.class);
3008                }
3009                public JavadocInlineTagContext javadocInlineTag(int i) {
3010                        return getRuleContext(JavadocInlineTagContext.class,i);
3011                }
3012                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3013                public TerminalNode LEADING_ASTERISK(int i) {
3014                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3015                }
3016                public TrContext(ParserRuleContext parent, int invokingState) {
3017                        super(parent, invokingState);
3018                }
3019                @Override public int getRuleIndex() { return RULE_tr; }
3020        }
3021
3022        public final TrContext tr() throws RecognitionException {
3023                TrContext _localctx = new TrContext(_ctx, getState());
3024                enterRule(_localctx, 28, RULE_tr);
3025                try {
3026                        int _alt;
3027                        enterOuterAlt(_localctx, 1);
3028                        {
3029                        setState(461);
3030                        trTagStart(false);
3031                        setState(501);
3032                        _errHandler.sync(this);
3033                        _alt = getInterpreter().adaptivePredict(_input,28,_ctx);
3034                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3035                                if ( _alt==1 ) {
3036                                        {
3037                                        setState(499);
3038                                        _errHandler.sync(this);
3039                                        switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
3040                                        case 1:
3041                                                {
3042                                                setState(462);
3043                                                htmlTag();
3044                                                }
3045                                                break;
3046                                        case 2:
3047                                                {
3048                                                setState(463);
3049                                                singletonElement();
3050                                                }
3051                                                break;
3052                                        case 3:
3053                                                {
3054                                                setState(464);
3055                                                paragraph();
3056                                                }
3057                                                break;
3058                                        case 4:
3059                                                {
3060                                                setState(465);
3061                                                li();
3062                                                }
3063                                                break;
3064                                        case 5:
3065                                                {
3066                                                setState(466);
3067                                                td();
3068                                                }
3069                                                break;
3070                                        case 6:
3071                                                {
3072                                                setState(467);
3073                                                th();
3074                                                }
3075                                                break;
3076                                        case 7:
3077                                                {
3078                                                setState(468);
3079                                                body();
3080                                                }
3081                                                break;
3082                                        case 8:
3083                                                {
3084                                                setState(469);
3085                                                colgroup();
3086                                                }
3087                                                break;
3088                                        case 9:
3089                                                {
3090                                                setState(470);
3091                                                dd();
3092                                                }
3093                                                break;
3094                                        case 10:
3095                                                {
3096                                                setState(471);
3097                                                dt();
3098                                                }
3099                                                break;
3100                                        case 11:
3101                                                {
3102                                                setState(472);
3103                                                head();
3104                                                }
3105                                                break;
3106                                        case 12:
3107                                                {
3108                                                setState(473);
3109                                                html();
3110                                                }
3111                                                break;
3112                                        case 13:
3113                                                {
3114                                                setState(474);
3115                                                option();
3116                                                }
3117                                                break;
3118                                        case 14:
3119                                                {
3120                                                setState(475);
3121                                                tbody();
3122                                                }
3123                                                break;
3124                                        case 15:
3125                                                {
3126                                                setState(476);
3127                                                thead();
3128                                                }
3129                                                break;
3130                                        case 16:
3131                                                {
3132                                                setState(477);
3133                                                tfoot();
3134                                                }
3135                                                break;
3136                                        case 17:
3137                                                {
3138                                                setState(478);
3139                                                pTagStart(true);
3140                                                }
3141                                                break;
3142                                        case 18:
3143                                                {
3144                                                setState(479);
3145                                                liTagStart(true);
3146                                                }
3147                                                break;
3148                                        case 19:
3149                                                {
3150                                                setState(480);
3151                                                tdTagStart(true);
3152                                                }
3153                                                break;
3154                                        case 20:
3155                                                {
3156                                                setState(481);
3157                                                thTagStart(true);
3158                                                }
3159                                                break;
3160                                        case 21:
3161                                                {
3162                                                setState(482);
3163                                                bodyTagStart(true);
3164                                                }
3165                                                break;
3166                                        case 22:
3167                                                {
3168                                                setState(483);
3169                                                colgroupTagStart(true);
3170                                                }
3171                                                break;
3172                                        case 23:
3173                                                {
3174                                                setState(484);
3175                                                ddTagStart(true);
3176                                                }
3177                                                break;
3178                                        case 24:
3179                                                {
3180                                                setState(485);
3181                                                dtTagStart(true);
3182                                                }
3183                                                break;
3184                                        case 25:
3185                                                {
3186                                                setState(486);
3187                                                headTagStart(true);
3188                                                }
3189                                                break;
3190                                        case 26:
3191                                                {
3192                                                setState(487);
3193                                                htmlTagStart(true);
3194                                                }
3195                                                break;
3196                                        case 27:
3197                                                {
3198                                                setState(488);
3199                                                optionTagStart(true);
3200                                                }
3201                                                break;
3202                                        case 28:
3203                                                {
3204                                                setState(489);
3205                                                tbodyTagStart(true);
3206                                                }
3207                                                break;
3208                                        case 29:
3209                                                {
3210                                                setState(490);
3211                                                theadTagStart(true);
3212                                                }
3213                                                break;
3214                                        case 30:
3215                                                {
3216                                                setState(491);
3217                                                tfootTagStart(true);
3218                                                }
3219                                                break;
3220                                        case 31:
3221                                                {
3222                                                {
3223                                                setState(492);
3224                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3225                                                setState(493);
3226                                                match(LEADING_ASTERISK);
3227                                                }
3228                                                }
3229                                                break;
3230                                        case 32:
3231                                                {
3232                                                setState(494);
3233                                                htmlComment();
3234                                                }
3235                                                break;
3236                                        case 33:
3237                                                {
3238                                                setState(495);
3239                                                match(CDATA);
3240                                                }
3241                                                break;
3242                                        case 34:
3243                                                {
3244                                                setState(496);
3245                                                match(NEWLINE);
3246                                                }
3247                                                break;
3248                                        case 35:
3249                                                {
3250                                                setState(497);
3251                                                text();
3252                                                }
3253                                                break;
3254                                        case 36:
3255                                                {
3256                                                setState(498);
3257                                                javadocInlineTag();
3258                                                }
3259                                                break;
3260                                        }
3261                                        } 
3262                                }
3263                                setState(503);
3264                                _errHandler.sync(this);
3265                                _alt = getInterpreter().adaptivePredict(_input,28,_ctx);
3266                        }
3267                        setState(504);
3268                        trTagEnd();
3269                        }
3270                }
3271                catch (RecognitionException re) {
3272                        _localctx.exception = re;
3273                        _errHandler.reportError(this, re);
3274                        _errHandler.recover(this, re);
3275                }
3276                finally {
3277                        exitRule();
3278                }
3279                return _localctx;
3280        }
3281
3282        public static class TdTagStartContext extends ParserRuleContext {
3283                public boolean isNonTight;
3284                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
3285                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3286                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
3287                public List<AttributeContext> attribute() {
3288                        return getRuleContexts(AttributeContext.class);
3289                }
3290                public AttributeContext attribute(int i) {
3291                        return getRuleContext(AttributeContext.class,i);
3292                }
3293                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3294                public TerminalNode NEWLINE(int i) {
3295                        return getToken(JavadocParser.NEWLINE, i);
3296                }
3297                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3298                public TerminalNode LEADING_ASTERISK(int i) {
3299                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3300                }
3301                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3302                public TerminalNode WS(int i) {
3303                        return getToken(JavadocParser.WS, i);
3304                }
3305                public TdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
3306                public TdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
3307                        super(parent, invokingState);
3308                        this.isNonTight = isNonTight;
3309                }
3310                @Override public int getRuleIndex() { return RULE_tdTagStart; }
3311        }
3312
3313        public final TdTagStartContext tdTagStart(boolean isNonTight) throws RecognitionException {
3314                TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight);
3315                enterRule(_localctx, 30, RULE_tdTagStart);
3316                int _la;
3317                try {
3318                        enterOuterAlt(_localctx, 1);
3319                        {
3320                        setState(506);
3321                        match(START);
3322                        setState(507);
3323                        match(TD_HTML_TAG_NAME);
3324                        setState(514);
3325                        _errHandler.sync(this);
3326                        _la = _input.LA(1);
3327                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3328                                {
3329                                setState(512);
3330                                _errHandler.sync(this);
3331                                switch (_input.LA(1)) {
3332                                case HTML_TAG_NAME:
3333                                        {
3334                                        setState(508);
3335                                        attribute();
3336                                        }
3337                                        break;
3338                                case NEWLINE:
3339                                        {
3340                                        setState(509);
3341                                        match(NEWLINE);
3342                                        }
3343                                        break;
3344                                case LEADING_ASTERISK:
3345                                        {
3346                                        setState(510);
3347                                        match(LEADING_ASTERISK);
3348                                        }
3349                                        break;
3350                                case WS:
3351                                        {
3352                                        setState(511);
3353                                        match(WS);
3354                                        }
3355                                        break;
3356                                default:
3357                                        throw new NoViableAltException(this);
3358                                }
3359                                }
3360                                setState(516);
3361                                _errHandler.sync(this);
3362                                _la = _input.LA(1);
3363                        }
3364                        setState(517);
3365                        match(END);
3366                        }
3367                        _ctx.stop = _input.LT(-1);
3368
3369                            if (isNonTight && nonTightTagStartContext == null) {
3370                                nonTightTagStartContext = _localctx;
3371                            }
3372
3373                }
3374                catch (RecognitionException re) {
3375                        _localctx.exception = re;
3376                        _errHandler.reportError(this, re);
3377                        _errHandler.recover(this, re);
3378                }
3379                finally {
3380                        exitRule();
3381                }
3382                return _localctx;
3383        }
3384
3385        public static class TdTagEndContext extends ParserRuleContext {
3386                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
3387                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3388                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3389                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
3390                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3391                public TerminalNode NEWLINE(int i) {
3392                        return getToken(JavadocParser.NEWLINE, i);
3393                }
3394                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3395                public TerminalNode LEADING_ASTERISK(int i) {
3396                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3397                }
3398                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3399                public TerminalNode WS(int i) {
3400                        return getToken(JavadocParser.WS, i);
3401                }
3402                public TdTagEndContext(ParserRuleContext parent, int invokingState) {
3403                        super(parent, invokingState);
3404                }
3405                @Override public int getRuleIndex() { return RULE_tdTagEnd; }
3406        }
3407
3408        public final TdTagEndContext tdTagEnd() throws RecognitionException {
3409                TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState());
3410                enterRule(_localctx, 32, RULE_tdTagEnd);
3411                int _la;
3412                try {
3413                        enterOuterAlt(_localctx, 1);
3414                        {
3415                        setState(519);
3416                        match(START);
3417                        setState(520);
3418                        match(SLASH);
3419                        setState(521);
3420                        match(TD_HTML_TAG_NAME);
3421                        setState(525);
3422                        _errHandler.sync(this);
3423                        _la = _input.LA(1);
3424                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3425                                {
3426                                {
3427                                setState(522);
3428                                _la = _input.LA(1);
3429                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3430                                _errHandler.recoverInline(this);
3431                                }
3432                                else {
3433                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
3434                                        _errHandler.reportMatch(this);
3435                                        consume();
3436                                }
3437                                }
3438                                }
3439                                setState(527);
3440                                _errHandler.sync(this);
3441                                _la = _input.LA(1);
3442                        }
3443                        setState(528);
3444                        match(END);
3445                        }
3446                }
3447                catch (RecognitionException re) {
3448                        _localctx.exception = re;
3449                        _errHandler.reportError(this, re);
3450                        _errHandler.recover(this, re);
3451                }
3452                finally {
3453                        exitRule();
3454                }
3455                return _localctx;
3456        }
3457
3458        public static class TdContext extends ParserRuleContext {
3459                public List<TdTagStartContext> tdTagStart() {
3460                        return getRuleContexts(TdTagStartContext.class);
3461                }
3462                public TdTagStartContext tdTagStart(int i) {
3463                        return getRuleContext(TdTagStartContext.class,i);
3464                }
3465                public TdTagEndContext tdTagEnd() {
3466                        return getRuleContext(TdTagEndContext.class,0);
3467                }
3468                public List<HtmlTagContext> htmlTag() {
3469                        return getRuleContexts(HtmlTagContext.class);
3470                }
3471                public HtmlTagContext htmlTag(int i) {
3472                        return getRuleContext(HtmlTagContext.class,i);
3473                }
3474                public List<SingletonElementContext> singletonElement() {
3475                        return getRuleContexts(SingletonElementContext.class);
3476                }
3477                public SingletonElementContext singletonElement(int i) {
3478                        return getRuleContext(SingletonElementContext.class,i);
3479                }
3480                public List<ParagraphContext> paragraph() {
3481                        return getRuleContexts(ParagraphContext.class);
3482                }
3483                public ParagraphContext paragraph(int i) {
3484                        return getRuleContext(ParagraphContext.class,i);
3485                }
3486                public List<LiContext> li() {
3487                        return getRuleContexts(LiContext.class);
3488                }
3489                public LiContext li(int i) {
3490                        return getRuleContext(LiContext.class,i);
3491                }
3492                public List<TrContext> tr() {
3493                        return getRuleContexts(TrContext.class);
3494                }
3495                public TrContext tr(int i) {
3496                        return getRuleContext(TrContext.class,i);
3497                }
3498                public List<ThContext> th() {
3499                        return getRuleContexts(ThContext.class);
3500                }
3501                public ThContext th(int i) {
3502                        return getRuleContext(ThContext.class,i);
3503                }
3504                public List<BodyContext> body() {
3505                        return getRuleContexts(BodyContext.class);
3506                }
3507                public BodyContext body(int i) {
3508                        return getRuleContext(BodyContext.class,i);
3509                }
3510                public List<ColgroupContext> colgroup() {
3511                        return getRuleContexts(ColgroupContext.class);
3512                }
3513                public ColgroupContext colgroup(int i) {
3514                        return getRuleContext(ColgroupContext.class,i);
3515                }
3516                public List<DdContext> dd() {
3517                        return getRuleContexts(DdContext.class);
3518                }
3519                public DdContext dd(int i) {
3520                        return getRuleContext(DdContext.class,i);
3521                }
3522                public List<DtContext> dt() {
3523                        return getRuleContexts(DtContext.class);
3524                }
3525                public DtContext dt(int i) {
3526                        return getRuleContext(DtContext.class,i);
3527                }
3528                public List<HeadContext> head() {
3529                        return getRuleContexts(HeadContext.class);
3530                }
3531                public HeadContext head(int i) {
3532                        return getRuleContext(HeadContext.class,i);
3533                }
3534                public List<HtmlContext> html() {
3535                        return getRuleContexts(HtmlContext.class);
3536                }
3537                public HtmlContext html(int i) {
3538                        return getRuleContext(HtmlContext.class,i);
3539                }
3540                public List<OptionContext> option() {
3541                        return getRuleContexts(OptionContext.class);
3542                }
3543                public OptionContext option(int i) {
3544                        return getRuleContext(OptionContext.class,i);
3545                }
3546                public List<TbodyContext> tbody() {
3547                        return getRuleContexts(TbodyContext.class);
3548                }
3549                public TbodyContext tbody(int i) {
3550                        return getRuleContext(TbodyContext.class,i);
3551                }
3552                public List<TheadContext> thead() {
3553                        return getRuleContexts(TheadContext.class);
3554                }
3555                public TheadContext thead(int i) {
3556                        return getRuleContext(TheadContext.class,i);
3557                }
3558                public List<TfootContext> tfoot() {
3559                        return getRuleContexts(TfootContext.class);
3560                }
3561                public TfootContext tfoot(int i) {
3562                        return getRuleContext(TfootContext.class,i);
3563                }
3564                public List<PTagStartContext> pTagStart() {
3565                        return getRuleContexts(PTagStartContext.class);
3566                }
3567                public PTagStartContext pTagStart(int i) {
3568                        return getRuleContext(PTagStartContext.class,i);
3569                }
3570                public List<LiTagStartContext> liTagStart() {
3571                        return getRuleContexts(LiTagStartContext.class);
3572                }
3573                public LiTagStartContext liTagStart(int i) {
3574                        return getRuleContext(LiTagStartContext.class,i);
3575                }
3576                public List<ThTagStartContext> thTagStart() {
3577                        return getRuleContexts(ThTagStartContext.class);
3578                }
3579                public ThTagStartContext thTagStart(int i) {
3580                        return getRuleContext(ThTagStartContext.class,i);
3581                }
3582                public List<BodyTagStartContext> bodyTagStart() {
3583                        return getRuleContexts(BodyTagStartContext.class);
3584                }
3585                public BodyTagStartContext bodyTagStart(int i) {
3586                        return getRuleContext(BodyTagStartContext.class,i);
3587                }
3588                public List<ColgroupTagStartContext> colgroupTagStart() {
3589                        return getRuleContexts(ColgroupTagStartContext.class);
3590                }
3591                public ColgroupTagStartContext colgroupTagStart(int i) {
3592                        return getRuleContext(ColgroupTagStartContext.class,i);
3593                }
3594                public List<DdTagStartContext> ddTagStart() {
3595                        return getRuleContexts(DdTagStartContext.class);
3596                }
3597                public DdTagStartContext ddTagStart(int i) {
3598                        return getRuleContext(DdTagStartContext.class,i);
3599                }
3600                public List<DtTagStartContext> dtTagStart() {
3601                        return getRuleContexts(DtTagStartContext.class);
3602                }
3603                public DtTagStartContext dtTagStart(int i) {
3604                        return getRuleContext(DtTagStartContext.class,i);
3605                }
3606                public List<HeadTagStartContext> headTagStart() {
3607                        return getRuleContexts(HeadTagStartContext.class);
3608                }
3609                public HeadTagStartContext headTagStart(int i) {
3610                        return getRuleContext(HeadTagStartContext.class,i);
3611                }
3612                public List<HtmlTagStartContext> htmlTagStart() {
3613                        return getRuleContexts(HtmlTagStartContext.class);
3614                }
3615                public HtmlTagStartContext htmlTagStart(int i) {
3616                        return getRuleContext(HtmlTagStartContext.class,i);
3617                }
3618                public List<OptionTagStartContext> optionTagStart() {
3619                        return getRuleContexts(OptionTagStartContext.class);
3620                }
3621                public OptionTagStartContext optionTagStart(int i) {
3622                        return getRuleContext(OptionTagStartContext.class,i);
3623                }
3624                public List<TbodyTagStartContext> tbodyTagStart() {
3625                        return getRuleContexts(TbodyTagStartContext.class);
3626                }
3627                public TbodyTagStartContext tbodyTagStart(int i) {
3628                        return getRuleContext(TbodyTagStartContext.class,i);
3629                }
3630                public List<TheadTagStartContext> theadTagStart() {
3631                        return getRuleContexts(TheadTagStartContext.class);
3632                }
3633                public TheadTagStartContext theadTagStart(int i) {
3634                        return getRuleContext(TheadTagStartContext.class,i);
3635                }
3636                public List<TfootTagStartContext> tfootTagStart() {
3637                        return getRuleContexts(TfootTagStartContext.class);
3638                }
3639                public TfootTagStartContext tfootTagStart(int i) {
3640                        return getRuleContext(TfootTagStartContext.class,i);
3641                }
3642                public List<HtmlCommentContext> htmlComment() {
3643                        return getRuleContexts(HtmlCommentContext.class);
3644                }
3645                public HtmlCommentContext htmlComment(int i) {
3646                        return getRuleContext(HtmlCommentContext.class,i);
3647                }
3648                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3649                public TerminalNode CDATA(int i) {
3650                        return getToken(JavadocParser.CDATA, i);
3651                }
3652                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3653                public TerminalNode NEWLINE(int i) {
3654                        return getToken(JavadocParser.NEWLINE, i);
3655                }
3656                public List<TextContext> text() {
3657                        return getRuleContexts(TextContext.class);
3658                }
3659                public TextContext text(int i) {
3660                        return getRuleContext(TextContext.class,i);
3661                }
3662                public List<JavadocInlineTagContext> javadocInlineTag() {
3663                        return getRuleContexts(JavadocInlineTagContext.class);
3664                }
3665                public JavadocInlineTagContext javadocInlineTag(int i) {
3666                        return getRuleContext(JavadocInlineTagContext.class,i);
3667                }
3668                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3669                public TerminalNode LEADING_ASTERISK(int i) {
3670                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3671                }
3672                public TdContext(ParserRuleContext parent, int invokingState) {
3673                        super(parent, invokingState);
3674                }
3675                @Override public int getRuleIndex() { return RULE_td; }
3676        }
3677
3678        public final TdContext td() throws RecognitionException {
3679                TdContext _localctx = new TdContext(_ctx, getState());
3680                enterRule(_localctx, 34, RULE_td);
3681                try {
3682                        int _alt;
3683                        enterOuterAlt(_localctx, 1);
3684                        {
3685                        setState(530);
3686                        tdTagStart(false);
3687                        setState(570);
3688                        _errHandler.sync(this);
3689                        _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
3690                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3691                                if ( _alt==1 ) {
3692                                        {
3693                                        setState(568);
3694                                        _errHandler.sync(this);
3695                                        switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
3696                                        case 1:
3697                                                {
3698                                                setState(531);
3699                                                htmlTag();
3700                                                }
3701                                                break;
3702                                        case 2:
3703                                                {
3704                                                setState(532);
3705                                                singletonElement();
3706                                                }
3707                                                break;
3708                                        case 3:
3709                                                {
3710                                                setState(533);
3711                                                paragraph();
3712                                                }
3713                                                break;
3714                                        case 4:
3715                                                {
3716                                                setState(534);
3717                                                li();
3718                                                }
3719                                                break;
3720                                        case 5:
3721                                                {
3722                                                setState(535);
3723                                                tr();
3724                                                }
3725                                                break;
3726                                        case 6:
3727                                                {
3728                                                setState(536);
3729                                                th();
3730                                                }
3731                                                break;
3732                                        case 7:
3733                                                {
3734                                                setState(537);
3735                                                body();
3736                                                }
3737                                                break;
3738                                        case 8:
3739                                                {
3740                                                setState(538);
3741                                                colgroup();
3742                                                }
3743                                                break;
3744                                        case 9:
3745                                                {
3746                                                setState(539);
3747                                                dd();
3748                                                }
3749                                                break;
3750                                        case 10:
3751                                                {
3752                                                setState(540);
3753                                                dt();
3754                                                }
3755                                                break;
3756                                        case 11:
3757                                                {
3758                                                setState(541);
3759                                                head();
3760                                                }
3761                                                break;
3762                                        case 12:
3763                                                {
3764                                                setState(542);
3765                                                html();
3766                                                }
3767                                                break;
3768                                        case 13:
3769                                                {
3770                                                setState(543);
3771                                                option();
3772                                                }
3773                                                break;
3774                                        case 14:
3775                                                {
3776                                                setState(544);
3777                                                tbody();
3778                                                }
3779                                                break;
3780                                        case 15:
3781                                                {
3782                                                setState(545);
3783                                                thead();
3784                                                }
3785                                                break;
3786                                        case 16:
3787                                                {
3788                                                setState(546);
3789                                                tfoot();
3790                                                }
3791                                                break;
3792                                        case 17:
3793                                                {
3794                                                setState(547);
3795                                                pTagStart(true);
3796                                                }
3797                                                break;
3798                                        case 18:
3799                                                {
3800                                                setState(548);
3801                                                liTagStart(true);
3802                                                }
3803                                                break;
3804                                        case 19:
3805                                                {
3806                                                setState(549);
3807                                                tdTagStart(true);
3808                                                }
3809                                                break;
3810                                        case 20:
3811                                                {
3812                                                setState(550);
3813                                                thTagStart(true);
3814                                                }
3815                                                break;
3816                                        case 21:
3817                                                {
3818                                                setState(551);
3819                                                bodyTagStart(true);
3820                                                }
3821                                                break;
3822                                        case 22:
3823                                                {
3824                                                setState(552);
3825                                                colgroupTagStart(true);
3826                                                }
3827                                                break;
3828                                        case 23:
3829                                                {
3830                                                setState(553);
3831                                                ddTagStart(true);
3832                                                }
3833                                                break;
3834                                        case 24:
3835                                                {
3836                                                setState(554);
3837                                                dtTagStart(true);
3838                                                }
3839                                                break;
3840                                        case 25:
3841                                                {
3842                                                setState(555);
3843                                                headTagStart(true);
3844                                                }
3845                                                break;
3846                                        case 26:
3847                                                {
3848                                                setState(556);
3849                                                htmlTagStart(true);
3850                                                }
3851                                                break;
3852                                        case 27:
3853                                                {
3854                                                setState(557);
3855                                                optionTagStart(true);
3856                                                }
3857                                                break;
3858                                        case 28:
3859                                                {
3860                                                setState(558);
3861                                                tbodyTagStart(true);
3862                                                }
3863                                                break;
3864                                        case 29:
3865                                                {
3866                                                setState(559);
3867                                                theadTagStart(true);
3868                                                }
3869                                                break;
3870                                        case 30:
3871                                                {
3872                                                setState(560);
3873                                                tfootTagStart(true);
3874                                                }
3875                                                break;
3876                                        case 31:
3877                                                {
3878                                                {
3879                                                setState(561);
3880                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3881                                                setState(562);
3882                                                match(LEADING_ASTERISK);
3883                                                }
3884                                                }
3885                                                break;
3886                                        case 32:
3887                                                {
3888                                                setState(563);
3889                                                htmlComment();
3890                                                }
3891                                                break;
3892                                        case 33:
3893                                                {
3894                                                setState(564);
3895                                                match(CDATA);
3896                                                }
3897                                                break;
3898                                        case 34:
3899                                                {
3900                                                setState(565);
3901                                                match(NEWLINE);
3902                                                }
3903                                                break;
3904                                        case 35:
3905                                                {
3906                                                setState(566);
3907                                                text();
3908                                                }
3909                                                break;
3910                                        case 36:
3911                                                {
3912                                                setState(567);
3913                                                javadocInlineTag();
3914                                                }
3915                                                break;
3916                                        }
3917                                        } 
3918                                }
3919                                setState(572);
3920                                _errHandler.sync(this);
3921                                _alt = getInterpreter().adaptivePredict(_input,33,_ctx);
3922                        }
3923                        setState(573);
3924                        tdTagEnd();
3925                        }
3926                }
3927                catch (RecognitionException re) {
3928                        _localctx.exception = re;
3929                        _errHandler.reportError(this, re);
3930                        _errHandler.recover(this, re);
3931                }
3932                finally {
3933                        exitRule();
3934                }
3935                return _localctx;
3936        }
3937
3938        public static class ThTagStartContext extends ParserRuleContext {
3939                public boolean isNonTight;
3940                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
3941                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
3942                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
3943                public List<AttributeContext> attribute() {
3944                        return getRuleContexts(AttributeContext.class);
3945                }
3946                public AttributeContext attribute(int i) {
3947                        return getRuleContext(AttributeContext.class,i);
3948                }
3949                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3950                public TerminalNode NEWLINE(int i) {
3951                        return getToken(JavadocParser.NEWLINE, i);
3952                }
3953                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3954                public TerminalNode LEADING_ASTERISK(int i) {
3955                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3956                }
3957                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3958                public TerminalNode WS(int i) {
3959                        return getToken(JavadocParser.WS, i);
3960                }
3961                public ThTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
3962                public ThTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
3963                        super(parent, invokingState);
3964                        this.isNonTight = isNonTight;
3965                }
3966                @Override public int getRuleIndex() { return RULE_thTagStart; }
3967        }
3968
3969        public final ThTagStartContext thTagStart(boolean isNonTight) throws RecognitionException {
3970                ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight);
3971                enterRule(_localctx, 36, RULE_thTagStart);
3972                int _la;
3973                try {
3974                        enterOuterAlt(_localctx, 1);
3975                        {
3976                        setState(575);
3977                        match(START);
3978                        setState(576);
3979                        match(TH_HTML_TAG_NAME);
3980                        setState(583);
3981                        _errHandler.sync(this);
3982                        _la = _input.LA(1);
3983                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3984                                {
3985                                setState(581);
3986                                _errHandler.sync(this);
3987                                switch (_input.LA(1)) {
3988                                case HTML_TAG_NAME:
3989                                        {
3990                                        setState(577);
3991                                        attribute();
3992                                        }
3993                                        break;
3994                                case NEWLINE:
3995                                        {
3996                                        setState(578);
3997                                        match(NEWLINE);
3998                                        }
3999                                        break;
4000                                case LEADING_ASTERISK:
4001                                        {
4002                                        setState(579);
4003                                        match(LEADING_ASTERISK);
4004                                        }
4005                                        break;
4006                                case WS:
4007                                        {
4008                                        setState(580);
4009                                        match(WS);
4010                                        }
4011                                        break;
4012                                default:
4013                                        throw new NoViableAltException(this);
4014                                }
4015                                }
4016                                setState(585);
4017                                _errHandler.sync(this);
4018                                _la = _input.LA(1);
4019                        }
4020                        setState(586);
4021                        match(END);
4022                        }
4023                        _ctx.stop = _input.LT(-1);
4024
4025                            if (isNonTight && nonTightTagStartContext == null) {
4026                                nonTightTagStartContext = _localctx;
4027                            }
4028
4029                }
4030                catch (RecognitionException re) {
4031                        _localctx.exception = re;
4032                        _errHandler.reportError(this, re);
4033                        _errHandler.recover(this, re);
4034                }
4035                finally {
4036                        exitRule();
4037                }
4038                return _localctx;
4039        }
4040
4041        public static class ThTagEndContext extends ParserRuleContext {
4042                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
4043                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4044                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4045                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
4046                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4047                public TerminalNode NEWLINE(int i) {
4048                        return getToken(JavadocParser.NEWLINE, i);
4049                }
4050                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4051                public TerminalNode LEADING_ASTERISK(int i) {
4052                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4053                }
4054                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4055                public TerminalNode WS(int i) {
4056                        return getToken(JavadocParser.WS, i);
4057                }
4058                public ThTagEndContext(ParserRuleContext parent, int invokingState) {
4059                        super(parent, invokingState);
4060                }
4061                @Override public int getRuleIndex() { return RULE_thTagEnd; }
4062        }
4063
4064        public final ThTagEndContext thTagEnd() throws RecognitionException {
4065                ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState());
4066                enterRule(_localctx, 38, RULE_thTagEnd);
4067                int _la;
4068                try {
4069                        enterOuterAlt(_localctx, 1);
4070                        {
4071                        setState(588);
4072                        match(START);
4073                        setState(589);
4074                        match(SLASH);
4075                        setState(590);
4076                        match(TH_HTML_TAG_NAME);
4077                        setState(594);
4078                        _errHandler.sync(this);
4079                        _la = _input.LA(1);
4080                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4081                                {
4082                                {
4083                                setState(591);
4084                                _la = _input.LA(1);
4085                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4086                                _errHandler.recoverInline(this);
4087                                }
4088                                else {
4089                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
4090                                        _errHandler.reportMatch(this);
4091                                        consume();
4092                                }
4093                                }
4094                                }
4095                                setState(596);
4096                                _errHandler.sync(this);
4097                                _la = _input.LA(1);
4098                        }
4099                        setState(597);
4100                        match(END);
4101                        }
4102                }
4103                catch (RecognitionException re) {
4104                        _localctx.exception = re;
4105                        _errHandler.reportError(this, re);
4106                        _errHandler.recover(this, re);
4107                }
4108                finally {
4109                        exitRule();
4110                }
4111                return _localctx;
4112        }
4113
4114        public static class ThContext extends ParserRuleContext {
4115                public ThTagStartContext thTagStart() {
4116                        return getRuleContext(ThTagStartContext.class,0);
4117                }
4118                public ThTagEndContext thTagEnd() {
4119                        return getRuleContext(ThTagEndContext.class,0);
4120                }
4121                public List<HtmlTagContext> htmlTag() {
4122                        return getRuleContexts(HtmlTagContext.class);
4123                }
4124                public HtmlTagContext htmlTag(int i) {
4125                        return getRuleContext(HtmlTagContext.class,i);
4126                }
4127                public List<SingletonElementContext> singletonElement() {
4128                        return getRuleContexts(SingletonElementContext.class);
4129                }
4130                public SingletonElementContext singletonElement(int i) {
4131                        return getRuleContext(SingletonElementContext.class,i);
4132                }
4133                public List<ParagraphContext> paragraph() {
4134                        return getRuleContexts(ParagraphContext.class);
4135                }
4136                public ParagraphContext paragraph(int i) {
4137                        return getRuleContext(ParagraphContext.class,i);
4138                }
4139                public List<LiContext> li() {
4140                        return getRuleContexts(LiContext.class);
4141                }
4142                public LiContext li(int i) {
4143                        return getRuleContext(LiContext.class,i);
4144                }
4145                public List<TrContext> tr() {
4146                        return getRuleContexts(TrContext.class);
4147                }
4148                public TrContext tr(int i) {
4149                        return getRuleContext(TrContext.class,i);
4150                }
4151                public List<TdContext> td() {
4152                        return getRuleContexts(TdContext.class);
4153                }
4154                public TdContext td(int i) {
4155                        return getRuleContext(TdContext.class,i);
4156                }
4157                public List<BodyContext> body() {
4158                        return getRuleContexts(BodyContext.class);
4159                }
4160                public BodyContext body(int i) {
4161                        return getRuleContext(BodyContext.class,i);
4162                }
4163                public List<ColgroupContext> colgroup() {
4164                        return getRuleContexts(ColgroupContext.class);
4165                }
4166                public ColgroupContext colgroup(int i) {
4167                        return getRuleContext(ColgroupContext.class,i);
4168                }
4169                public List<DdContext> dd() {
4170                        return getRuleContexts(DdContext.class);
4171                }
4172                public DdContext dd(int i) {
4173                        return getRuleContext(DdContext.class,i);
4174                }
4175                public List<DtContext> dt() {
4176                        return getRuleContexts(DtContext.class);
4177                }
4178                public DtContext dt(int i) {
4179                        return getRuleContext(DtContext.class,i);
4180                }
4181                public List<HeadContext> head() {
4182                        return getRuleContexts(HeadContext.class);
4183                }
4184                public HeadContext head(int i) {
4185                        return getRuleContext(HeadContext.class,i);
4186                }
4187                public List<HtmlContext> html() {
4188                        return getRuleContexts(HtmlContext.class);
4189                }
4190                public HtmlContext html(int i) {
4191                        return getRuleContext(HtmlContext.class,i);
4192                }
4193                public List<OptionContext> option() {
4194                        return getRuleContexts(OptionContext.class);
4195                }
4196                public OptionContext option(int i) {
4197                        return getRuleContext(OptionContext.class,i);
4198                }
4199                public List<TbodyContext> tbody() {
4200                        return getRuleContexts(TbodyContext.class);
4201                }
4202                public TbodyContext tbody(int i) {
4203                        return getRuleContext(TbodyContext.class,i);
4204                }
4205                public List<TheadContext> thead() {
4206                        return getRuleContexts(TheadContext.class);
4207                }
4208                public TheadContext thead(int i) {
4209                        return getRuleContext(TheadContext.class,i);
4210                }
4211                public List<TfootContext> tfoot() {
4212                        return getRuleContexts(TfootContext.class);
4213                }
4214                public TfootContext tfoot(int i) {
4215                        return getRuleContext(TfootContext.class,i);
4216                }
4217                public List<PTagStartContext> pTagStart() {
4218                        return getRuleContexts(PTagStartContext.class);
4219                }
4220                public PTagStartContext pTagStart(int i) {
4221                        return getRuleContext(PTagStartContext.class,i);
4222                }
4223                public List<LiTagStartContext> liTagStart() {
4224                        return getRuleContexts(LiTagStartContext.class);
4225                }
4226                public LiTagStartContext liTagStart(int i) {
4227                        return getRuleContext(LiTagStartContext.class,i);
4228                }
4229                public List<TrTagStartContext> trTagStart() {
4230                        return getRuleContexts(TrTagStartContext.class);
4231                }
4232                public TrTagStartContext trTagStart(int i) {
4233                        return getRuleContext(TrTagStartContext.class,i);
4234                }
4235                public List<TdTagStartContext> tdTagStart() {
4236                        return getRuleContexts(TdTagStartContext.class);
4237                }
4238                public TdTagStartContext tdTagStart(int i) {
4239                        return getRuleContext(TdTagStartContext.class,i);
4240                }
4241                public List<BodyTagStartContext> bodyTagStart() {
4242                        return getRuleContexts(BodyTagStartContext.class);
4243                }
4244                public BodyTagStartContext bodyTagStart(int i) {
4245                        return getRuleContext(BodyTagStartContext.class,i);
4246                }
4247                public List<ColgroupTagStartContext> colgroupTagStart() {
4248                        return getRuleContexts(ColgroupTagStartContext.class);
4249                }
4250                public ColgroupTagStartContext colgroupTagStart(int i) {
4251                        return getRuleContext(ColgroupTagStartContext.class,i);
4252                }
4253                public List<DdTagStartContext> ddTagStart() {
4254                        return getRuleContexts(DdTagStartContext.class);
4255                }
4256                public DdTagStartContext ddTagStart(int i) {
4257                        return getRuleContext(DdTagStartContext.class,i);
4258                }
4259                public List<DtTagStartContext> dtTagStart() {
4260                        return getRuleContexts(DtTagStartContext.class);
4261                }
4262                public DtTagStartContext dtTagStart(int i) {
4263                        return getRuleContext(DtTagStartContext.class,i);
4264                }
4265                public List<HeadTagStartContext> headTagStart() {
4266                        return getRuleContexts(HeadTagStartContext.class);
4267                }
4268                public HeadTagStartContext headTagStart(int i) {
4269                        return getRuleContext(HeadTagStartContext.class,i);
4270                }
4271                public List<HtmlTagStartContext> htmlTagStart() {
4272                        return getRuleContexts(HtmlTagStartContext.class);
4273                }
4274                public HtmlTagStartContext htmlTagStart(int i) {
4275                        return getRuleContext(HtmlTagStartContext.class,i);
4276                }
4277                public List<OptionTagStartContext> optionTagStart() {
4278                        return getRuleContexts(OptionTagStartContext.class);
4279                }
4280                public OptionTagStartContext optionTagStart(int i) {
4281                        return getRuleContext(OptionTagStartContext.class,i);
4282                }
4283                public List<TbodyTagStartContext> tbodyTagStart() {
4284                        return getRuleContexts(TbodyTagStartContext.class);
4285                }
4286                public TbodyTagStartContext tbodyTagStart(int i) {
4287                        return getRuleContext(TbodyTagStartContext.class,i);
4288                }
4289                public List<TheadTagStartContext> theadTagStart() {
4290                        return getRuleContexts(TheadTagStartContext.class);
4291                }
4292                public TheadTagStartContext theadTagStart(int i) {
4293                        return getRuleContext(TheadTagStartContext.class,i);
4294                }
4295                public List<TfootTagStartContext> tfootTagStart() {
4296                        return getRuleContexts(TfootTagStartContext.class);
4297                }
4298                public TfootTagStartContext tfootTagStart(int i) {
4299                        return getRuleContext(TfootTagStartContext.class,i);
4300                }
4301                public List<HtmlCommentContext> htmlComment() {
4302                        return getRuleContexts(HtmlCommentContext.class);
4303                }
4304                public HtmlCommentContext htmlComment(int i) {
4305                        return getRuleContext(HtmlCommentContext.class,i);
4306                }
4307                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4308                public TerminalNode CDATA(int i) {
4309                        return getToken(JavadocParser.CDATA, i);
4310                }
4311                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4312                public TerminalNode NEWLINE(int i) {
4313                        return getToken(JavadocParser.NEWLINE, i);
4314                }
4315                public List<TextContext> text() {
4316                        return getRuleContexts(TextContext.class);
4317                }
4318                public TextContext text(int i) {
4319                        return getRuleContext(TextContext.class,i);
4320                }
4321                public List<JavadocInlineTagContext> javadocInlineTag() {
4322                        return getRuleContexts(JavadocInlineTagContext.class);
4323                }
4324                public JavadocInlineTagContext javadocInlineTag(int i) {
4325                        return getRuleContext(JavadocInlineTagContext.class,i);
4326                }
4327                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4328                public TerminalNode LEADING_ASTERISK(int i) {
4329                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4330                }
4331                public ThContext(ParserRuleContext parent, int invokingState) {
4332                        super(parent, invokingState);
4333                }
4334                @Override public int getRuleIndex() { return RULE_th; }
4335        }
4336
4337        public final ThContext th() throws RecognitionException {
4338                ThContext _localctx = new ThContext(_ctx, getState());
4339                enterRule(_localctx, 40, RULE_th);
4340                try {
4341                        int _alt;
4342                        enterOuterAlt(_localctx, 1);
4343                        {
4344                        setState(599);
4345                        thTagStart(false);
4346                        setState(639);
4347                        _errHandler.sync(this);
4348                        _alt = getInterpreter().adaptivePredict(_input,38,_ctx);
4349                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4350                                if ( _alt==1 ) {
4351                                        {
4352                                        setState(637);
4353                                        _errHandler.sync(this);
4354                                        switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
4355                                        case 1:
4356                                                {
4357                                                setState(600);
4358                                                htmlTag();
4359                                                }
4360                                                break;
4361                                        case 2:
4362                                                {
4363                                                setState(601);
4364                                                singletonElement();
4365                                                }
4366                                                break;
4367                                        case 3:
4368                                                {
4369                                                setState(602);
4370                                                paragraph();
4371                                                }
4372                                                break;
4373                                        case 4:
4374                                                {
4375                                                setState(603);
4376                                                li();
4377                                                }
4378                                                break;
4379                                        case 5:
4380                                                {
4381                                                setState(604);
4382                                                tr();
4383                                                }
4384                                                break;
4385                                        case 6:
4386                                                {
4387                                                setState(605);
4388                                                td();
4389                                                }
4390                                                break;
4391                                        case 7:
4392                                                {
4393                                                setState(606);
4394                                                body();
4395                                                }
4396                                                break;
4397                                        case 8:
4398                                                {
4399                                                setState(607);
4400                                                colgroup();
4401                                                }
4402                                                break;
4403                                        case 9:
4404                                                {
4405                                                setState(608);
4406                                                dd();
4407                                                }
4408                                                break;
4409                                        case 10:
4410                                                {
4411                                                setState(609);
4412                                                dt();
4413                                                }
4414                                                break;
4415                                        case 11:
4416                                                {
4417                                                setState(610);
4418                                                head();
4419                                                }
4420                                                break;
4421                                        case 12:
4422                                                {
4423                                                setState(611);
4424                                                html();
4425                                                }
4426                                                break;
4427                                        case 13:
4428                                                {
4429                                                setState(612);
4430                                                option();
4431                                                }
4432                                                break;
4433                                        case 14:
4434                                                {
4435                                                setState(613);
4436                                                tbody();
4437                                                }
4438                                                break;
4439                                        case 15:
4440                                                {
4441                                                setState(614);
4442                                                thead();
4443                                                }
4444                                                break;
4445                                        case 16:
4446                                                {
4447                                                setState(615);
4448                                                tfoot();
4449                                                }
4450                                                break;
4451                                        case 17:
4452                                                {
4453                                                setState(616);
4454                                                pTagStart(true);
4455                                                }
4456                                                break;
4457                                        case 18:
4458                                                {
4459                                                setState(617);
4460                                                liTagStart(true);
4461                                                }
4462                                                break;
4463                                        case 19:
4464                                                {
4465                                                setState(618);
4466                                                trTagStart(true);
4467                                                }
4468                                                break;
4469                                        case 20:
4470                                                {
4471                                                setState(619);
4472                                                tdTagStart(true);
4473                                                }
4474                                                break;
4475                                        case 21:
4476                                                {
4477                                                setState(620);
4478                                                bodyTagStart(true);
4479                                                }
4480                                                break;
4481                                        case 22:
4482                                                {
4483                                                setState(621);
4484                                                colgroupTagStart(true);
4485                                                }
4486                                                break;
4487                                        case 23:
4488                                                {
4489                                                setState(622);
4490                                                ddTagStart(true);
4491                                                }
4492                                                break;
4493                                        case 24:
4494                                                {
4495                                                setState(623);
4496                                                dtTagStart(true);
4497                                                }
4498                                                break;
4499                                        case 25:
4500                                                {
4501                                                setState(624);
4502                                                headTagStart(true);
4503                                                }
4504                                                break;
4505                                        case 26:
4506                                                {
4507                                                setState(625);
4508                                                htmlTagStart(true);
4509                                                }
4510                                                break;
4511                                        case 27:
4512                                                {
4513                                                setState(626);
4514                                                optionTagStart(true);
4515                                                }
4516                                                break;
4517                                        case 28:
4518                                                {
4519                                                setState(627);
4520                                                tbodyTagStart(true);
4521                                                }
4522                                                break;
4523                                        case 29:
4524                                                {
4525                                                setState(628);
4526                                                theadTagStart(true);
4527                                                }
4528                                                break;
4529                                        case 30:
4530                                                {
4531                                                setState(629);
4532                                                tfootTagStart(true);
4533                                                }
4534                                                break;
4535                                        case 31:
4536                                                {
4537                                                {
4538                                                setState(630);
4539                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4540                                                setState(631);
4541                                                match(LEADING_ASTERISK);
4542                                                }
4543                                                }
4544                                                break;
4545                                        case 32:
4546                                                {
4547                                                setState(632);
4548                                                htmlComment();
4549                                                }
4550                                                break;
4551                                        case 33:
4552                                                {
4553                                                setState(633);
4554                                                match(CDATA);
4555                                                }
4556                                                break;
4557                                        case 34:
4558                                                {
4559                                                setState(634);
4560                                                match(NEWLINE);
4561                                                }
4562                                                break;
4563                                        case 35:
4564                                                {
4565                                                setState(635);
4566                                                text();
4567                                                }
4568                                                break;
4569                                        case 36:
4570                                                {
4571                                                setState(636);
4572                                                javadocInlineTag();
4573                                                }
4574                                                break;
4575                                        }
4576                                        } 
4577                                }
4578                                setState(641);
4579                                _errHandler.sync(this);
4580                                _alt = getInterpreter().adaptivePredict(_input,38,_ctx);
4581                        }
4582                        setState(642);
4583                        thTagEnd();
4584                        }
4585                }
4586                catch (RecognitionException re) {
4587                        _localctx.exception = re;
4588                        _errHandler.reportError(this, re);
4589                        _errHandler.recover(this, re);
4590                }
4591                finally {
4592                        exitRule();
4593                }
4594                return _localctx;
4595        }
4596
4597        public static class BodyTagStartContext extends ParserRuleContext {
4598                public boolean isNonTight;
4599                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
4600                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4601                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
4602                public List<AttributeContext> attribute() {
4603                        return getRuleContexts(AttributeContext.class);
4604                }
4605                public AttributeContext attribute(int i) {
4606                        return getRuleContext(AttributeContext.class,i);
4607                }
4608                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4609                public TerminalNode NEWLINE(int i) {
4610                        return getToken(JavadocParser.NEWLINE, i);
4611                }
4612                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4613                public TerminalNode LEADING_ASTERISK(int i) {
4614                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4615                }
4616                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4617                public TerminalNode WS(int i) {
4618                        return getToken(JavadocParser.WS, i);
4619                }
4620                public BodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
4621                public BodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
4622                        super(parent, invokingState);
4623                        this.isNonTight = isNonTight;
4624                }
4625                @Override public int getRuleIndex() { return RULE_bodyTagStart; }
4626        }
4627
4628        public final BodyTagStartContext bodyTagStart(boolean isNonTight) throws RecognitionException {
4629                BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight);
4630                enterRule(_localctx, 42, RULE_bodyTagStart);
4631                int _la;
4632                try {
4633                        enterOuterAlt(_localctx, 1);
4634                        {
4635                        setState(644);
4636                        match(START);
4637                        setState(645);
4638                        match(BODY_HTML_TAG_NAME);
4639                        setState(652);
4640                        _errHandler.sync(this);
4641                        _la = _input.LA(1);
4642                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4643                                {
4644                                setState(650);
4645                                _errHandler.sync(this);
4646                                switch (_input.LA(1)) {
4647                                case HTML_TAG_NAME:
4648                                        {
4649                                        setState(646);
4650                                        attribute();
4651                                        }
4652                                        break;
4653                                case NEWLINE:
4654                                        {
4655                                        setState(647);
4656                                        match(NEWLINE);
4657                                        }
4658                                        break;
4659                                case LEADING_ASTERISK:
4660                                        {
4661                                        setState(648);
4662                                        match(LEADING_ASTERISK);
4663                                        }
4664                                        break;
4665                                case WS:
4666                                        {
4667                                        setState(649);
4668                                        match(WS);
4669                                        }
4670                                        break;
4671                                default:
4672                                        throw new NoViableAltException(this);
4673                                }
4674                                }
4675                                setState(654);
4676                                _errHandler.sync(this);
4677                                _la = _input.LA(1);
4678                        }
4679                        setState(655);
4680                        match(END);
4681                        }
4682                        _ctx.stop = _input.LT(-1);
4683
4684                            if (isNonTight && nonTightTagStartContext == null) {
4685                                nonTightTagStartContext = _localctx;
4686                            }
4687
4688                }
4689                catch (RecognitionException re) {
4690                        _localctx.exception = re;
4691                        _errHandler.reportError(this, re);
4692                        _errHandler.recover(this, re);
4693                }
4694                finally {
4695                        exitRule();
4696                }
4697                return _localctx;
4698        }
4699
4700        public static class BodyTagEndContext extends ParserRuleContext {
4701                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
4702                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4703                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4704                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
4705                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4706                public TerminalNode NEWLINE(int i) {
4707                        return getToken(JavadocParser.NEWLINE, i);
4708                }
4709                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4710                public TerminalNode LEADING_ASTERISK(int i) {
4711                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4712                }
4713                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4714                public TerminalNode WS(int i) {
4715                        return getToken(JavadocParser.WS, i);
4716                }
4717                public BodyTagEndContext(ParserRuleContext parent, int invokingState) {
4718                        super(parent, invokingState);
4719                }
4720                @Override public int getRuleIndex() { return RULE_bodyTagEnd; }
4721        }
4722
4723        public final BodyTagEndContext bodyTagEnd() throws RecognitionException {
4724                BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState());
4725                enterRule(_localctx, 44, RULE_bodyTagEnd);
4726                int _la;
4727                try {
4728                        enterOuterAlt(_localctx, 1);
4729                        {
4730                        setState(657);
4731                        match(START);
4732                        setState(658);
4733                        match(SLASH);
4734                        setState(659);
4735                        match(BODY_HTML_TAG_NAME);
4736                        setState(663);
4737                        _errHandler.sync(this);
4738                        _la = _input.LA(1);
4739                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4740                                {
4741                                {
4742                                setState(660);
4743                                _la = _input.LA(1);
4744                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4745                                _errHandler.recoverInline(this);
4746                                }
4747                                else {
4748                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
4749                                        _errHandler.reportMatch(this);
4750                                        consume();
4751                                }
4752                                }
4753                                }
4754                                setState(665);
4755                                _errHandler.sync(this);
4756                                _la = _input.LA(1);
4757                        }
4758                        setState(666);
4759                        match(END);
4760                        }
4761                }
4762                catch (RecognitionException re) {
4763                        _localctx.exception = re;
4764                        _errHandler.reportError(this, re);
4765                        _errHandler.recover(this, re);
4766                }
4767                finally {
4768                        exitRule();
4769                }
4770                return _localctx;
4771        }
4772
4773        public static class BodyContext extends ParserRuleContext {
4774                public BodyTagStartContext bodyTagStart() {
4775                        return getRuleContext(BodyTagStartContext.class,0);
4776                }
4777                public BodyTagEndContext bodyTagEnd() {
4778                        return getRuleContext(BodyTagEndContext.class,0);
4779                }
4780                public List<HtmlTagContext> htmlTag() {
4781                        return getRuleContexts(HtmlTagContext.class);
4782                }
4783                public HtmlTagContext htmlTag(int i) {
4784                        return getRuleContext(HtmlTagContext.class,i);
4785                }
4786                public List<SingletonElementContext> singletonElement() {
4787                        return getRuleContexts(SingletonElementContext.class);
4788                }
4789                public SingletonElementContext singletonElement(int i) {
4790                        return getRuleContext(SingletonElementContext.class,i);
4791                }
4792                public List<ParagraphContext> paragraph() {
4793                        return getRuleContexts(ParagraphContext.class);
4794                }
4795                public ParagraphContext paragraph(int i) {
4796                        return getRuleContext(ParagraphContext.class,i);
4797                }
4798                public List<LiContext> li() {
4799                        return getRuleContexts(LiContext.class);
4800                }
4801                public LiContext li(int i) {
4802                        return getRuleContext(LiContext.class,i);
4803                }
4804                public List<TrContext> tr() {
4805                        return getRuleContexts(TrContext.class);
4806                }
4807                public TrContext tr(int i) {
4808                        return getRuleContext(TrContext.class,i);
4809                }
4810                public List<TdContext> td() {
4811                        return getRuleContexts(TdContext.class);
4812                }
4813                public TdContext td(int i) {
4814                        return getRuleContext(TdContext.class,i);
4815                }
4816                public List<ThContext> th() {
4817                        return getRuleContexts(ThContext.class);
4818                }
4819                public ThContext th(int i) {
4820                        return getRuleContext(ThContext.class,i);
4821                }
4822                public List<ColgroupContext> colgroup() {
4823                        return getRuleContexts(ColgroupContext.class);
4824                }
4825                public ColgroupContext colgroup(int i) {
4826                        return getRuleContext(ColgroupContext.class,i);
4827                }
4828                public List<DdContext> dd() {
4829                        return getRuleContexts(DdContext.class);
4830                }
4831                public DdContext dd(int i) {
4832                        return getRuleContext(DdContext.class,i);
4833                }
4834                public List<DtContext> dt() {
4835                        return getRuleContexts(DtContext.class);
4836                }
4837                public DtContext dt(int i) {
4838                        return getRuleContext(DtContext.class,i);
4839                }
4840                public List<HeadContext> head() {
4841                        return getRuleContexts(HeadContext.class);
4842                }
4843                public HeadContext head(int i) {
4844                        return getRuleContext(HeadContext.class,i);
4845                }
4846                public List<HtmlContext> html() {
4847                        return getRuleContexts(HtmlContext.class);
4848                }
4849                public HtmlContext html(int i) {
4850                        return getRuleContext(HtmlContext.class,i);
4851                }
4852                public List<OptionContext> option() {
4853                        return getRuleContexts(OptionContext.class);
4854                }
4855                public OptionContext option(int i) {
4856                        return getRuleContext(OptionContext.class,i);
4857                }
4858                public List<TbodyContext> tbody() {
4859                        return getRuleContexts(TbodyContext.class);
4860                }
4861                public TbodyContext tbody(int i) {
4862                        return getRuleContext(TbodyContext.class,i);
4863                }
4864                public List<TheadContext> thead() {
4865                        return getRuleContexts(TheadContext.class);
4866                }
4867                public TheadContext thead(int i) {
4868                        return getRuleContext(TheadContext.class,i);
4869                }
4870                public List<TfootContext> tfoot() {
4871                        return getRuleContexts(TfootContext.class);
4872                }
4873                public TfootContext tfoot(int i) {
4874                        return getRuleContext(TfootContext.class,i);
4875                }
4876                public List<PTagStartContext> pTagStart() {
4877                        return getRuleContexts(PTagStartContext.class);
4878                }
4879                public PTagStartContext pTagStart(int i) {
4880                        return getRuleContext(PTagStartContext.class,i);
4881                }
4882                public List<LiTagStartContext> liTagStart() {
4883                        return getRuleContexts(LiTagStartContext.class);
4884                }
4885                public LiTagStartContext liTagStart(int i) {
4886                        return getRuleContext(LiTagStartContext.class,i);
4887                }
4888                public List<TrTagStartContext> trTagStart() {
4889                        return getRuleContexts(TrTagStartContext.class);
4890                }
4891                public TrTagStartContext trTagStart(int i) {
4892                        return getRuleContext(TrTagStartContext.class,i);
4893                }
4894                public List<TdTagStartContext> tdTagStart() {
4895                        return getRuleContexts(TdTagStartContext.class);
4896                }
4897                public TdTagStartContext tdTagStart(int i) {
4898                        return getRuleContext(TdTagStartContext.class,i);
4899                }
4900                public List<ThTagStartContext> thTagStart() {
4901                        return getRuleContexts(ThTagStartContext.class);
4902                }
4903                public ThTagStartContext thTagStart(int i) {
4904                        return getRuleContext(ThTagStartContext.class,i);
4905                }
4906                public List<ColgroupTagStartContext> colgroupTagStart() {
4907                        return getRuleContexts(ColgroupTagStartContext.class);
4908                }
4909                public ColgroupTagStartContext colgroupTagStart(int i) {
4910                        return getRuleContext(ColgroupTagStartContext.class,i);
4911                }
4912                public List<DdTagStartContext> ddTagStart() {
4913                        return getRuleContexts(DdTagStartContext.class);
4914                }
4915                public DdTagStartContext ddTagStart(int i) {
4916                        return getRuleContext(DdTagStartContext.class,i);
4917                }
4918                public List<DtTagStartContext> dtTagStart() {
4919                        return getRuleContexts(DtTagStartContext.class);
4920                }
4921                public DtTagStartContext dtTagStart(int i) {
4922                        return getRuleContext(DtTagStartContext.class,i);
4923                }
4924                public List<HeadTagStartContext> headTagStart() {
4925                        return getRuleContexts(HeadTagStartContext.class);
4926                }
4927                public HeadTagStartContext headTagStart(int i) {
4928                        return getRuleContext(HeadTagStartContext.class,i);
4929                }
4930                public List<HtmlTagStartContext> htmlTagStart() {
4931                        return getRuleContexts(HtmlTagStartContext.class);
4932                }
4933                public HtmlTagStartContext htmlTagStart(int i) {
4934                        return getRuleContext(HtmlTagStartContext.class,i);
4935                }
4936                public List<OptionTagStartContext> optionTagStart() {
4937                        return getRuleContexts(OptionTagStartContext.class);
4938                }
4939                public OptionTagStartContext optionTagStart(int i) {
4940                        return getRuleContext(OptionTagStartContext.class,i);
4941                }
4942                public List<TbodyTagStartContext> tbodyTagStart() {
4943                        return getRuleContexts(TbodyTagStartContext.class);
4944                }
4945                public TbodyTagStartContext tbodyTagStart(int i) {
4946                        return getRuleContext(TbodyTagStartContext.class,i);
4947                }
4948                public List<TheadTagStartContext> theadTagStart() {
4949                        return getRuleContexts(TheadTagStartContext.class);
4950                }
4951                public TheadTagStartContext theadTagStart(int i) {
4952                        return getRuleContext(TheadTagStartContext.class,i);
4953                }
4954                public List<TfootTagStartContext> tfootTagStart() {
4955                        return getRuleContexts(TfootTagStartContext.class);
4956                }
4957                public TfootTagStartContext tfootTagStart(int i) {
4958                        return getRuleContext(TfootTagStartContext.class,i);
4959                }
4960                public List<HtmlCommentContext> htmlComment() {
4961                        return getRuleContexts(HtmlCommentContext.class);
4962                }
4963                public HtmlCommentContext htmlComment(int i) {
4964                        return getRuleContext(HtmlCommentContext.class,i);
4965                }
4966                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4967                public TerminalNode CDATA(int i) {
4968                        return getToken(JavadocParser.CDATA, i);
4969                }
4970                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4971                public TerminalNode NEWLINE(int i) {
4972                        return getToken(JavadocParser.NEWLINE, i);
4973                }
4974                public List<TextContext> text() {
4975                        return getRuleContexts(TextContext.class);
4976                }
4977                public TextContext text(int i) {
4978                        return getRuleContext(TextContext.class,i);
4979                }
4980                public List<JavadocInlineTagContext> javadocInlineTag() {
4981                        return getRuleContexts(JavadocInlineTagContext.class);
4982                }
4983                public JavadocInlineTagContext javadocInlineTag(int i) {
4984                        return getRuleContext(JavadocInlineTagContext.class,i);
4985                }
4986                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4987                public TerminalNode LEADING_ASTERISK(int i) {
4988                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4989                }
4990                public BodyContext(ParserRuleContext parent, int invokingState) {
4991                        super(parent, invokingState);
4992                }
4993                @Override public int getRuleIndex() { return RULE_body; }
4994        }
4995
4996        public final BodyContext body() throws RecognitionException {
4997                BodyContext _localctx = new BodyContext(_ctx, getState());
4998                enterRule(_localctx, 46, RULE_body);
4999                try {
5000                        int _alt;
5001                        enterOuterAlt(_localctx, 1);
5002                        {
5003                        setState(668);
5004                        bodyTagStart(false);
5005                        setState(708);
5006                        _errHandler.sync(this);
5007                        _alt = getInterpreter().adaptivePredict(_input,43,_ctx);
5008                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5009                                if ( _alt==1 ) {
5010                                        {
5011                                        setState(706);
5012                                        _errHandler.sync(this);
5013                                        switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
5014                                        case 1:
5015                                                {
5016                                                setState(669);
5017                                                htmlTag();
5018                                                }
5019                                                break;
5020                                        case 2:
5021                                                {
5022                                                setState(670);
5023                                                singletonElement();
5024                                                }
5025                                                break;
5026                                        case 3:
5027                                                {
5028                                                setState(671);
5029                                                paragraph();
5030                                                }
5031                                                break;
5032                                        case 4:
5033                                                {
5034                                                setState(672);
5035                                                li();
5036                                                }
5037                                                break;
5038                                        case 5:
5039                                                {
5040                                                setState(673);
5041                                                tr();
5042                                                }
5043                                                break;
5044                                        case 6:
5045                                                {
5046                                                setState(674);
5047                                                td();
5048                                                }
5049                                                break;
5050                                        case 7:
5051                                                {
5052                                                setState(675);
5053                                                th();
5054                                                }
5055                                                break;
5056                                        case 8:
5057                                                {
5058                                                setState(676);
5059                                                colgroup();
5060                                                }
5061                                                break;
5062                                        case 9:
5063                                                {
5064                                                setState(677);
5065                                                dd();
5066                                                }
5067                                                break;
5068                                        case 10:
5069                                                {
5070                                                setState(678);
5071                                                dt();
5072                                                }
5073                                                break;
5074                                        case 11:
5075                                                {
5076                                                setState(679);
5077                                                head();
5078                                                }
5079                                                break;
5080                                        case 12:
5081                                                {
5082                                                setState(680);
5083                                                html();
5084                                                }
5085                                                break;
5086                                        case 13:
5087                                                {
5088                                                setState(681);
5089                                                option();
5090                                                }
5091                                                break;
5092                                        case 14:
5093                                                {
5094                                                setState(682);
5095                                                tbody();
5096                                                }
5097                                                break;
5098                                        case 15:
5099                                                {
5100                                                setState(683);
5101                                                thead();
5102                                                }
5103                                                break;
5104                                        case 16:
5105                                                {
5106                                                setState(684);
5107                                                tfoot();
5108                                                }
5109                                                break;
5110                                        case 17:
5111                                                {
5112                                                setState(685);
5113                                                pTagStart(true);
5114                                                }
5115                                                break;
5116                                        case 18:
5117                                                {
5118                                                setState(686);
5119                                                liTagStart(true);
5120                                                }
5121                                                break;
5122                                        case 19:
5123                                                {
5124                                                setState(687);
5125                                                trTagStart(true);
5126                                                }
5127                                                break;
5128                                        case 20:
5129                                                {
5130                                                setState(688);
5131                                                tdTagStart(true);
5132                                                }
5133                                                break;
5134                                        case 21:
5135                                                {
5136                                                setState(689);
5137                                                thTagStart(true);
5138                                                }
5139                                                break;
5140                                        case 22:
5141                                                {
5142                                                setState(690);
5143                                                colgroupTagStart(true);
5144                                                }
5145                                                break;
5146                                        case 23:
5147                                                {
5148                                                setState(691);
5149                                                ddTagStart(true);
5150                                                }
5151                                                break;
5152                                        case 24:
5153                                                {
5154                                                setState(692);
5155                                                dtTagStart(true);
5156                                                }
5157                                                break;
5158                                        case 25:
5159                                                {
5160                                                setState(693);
5161                                                headTagStart(true);
5162                                                }
5163                                                break;
5164                                        case 26:
5165                                                {
5166                                                setState(694);
5167                                                htmlTagStart(true);
5168                                                }
5169                                                break;
5170                                        case 27:
5171                                                {
5172                                                setState(695);
5173                                                optionTagStart(true);
5174                                                }
5175                                                break;
5176                                        case 28:
5177                                                {
5178                                                setState(696);
5179                                                tbodyTagStart(true);
5180                                                }
5181                                                break;
5182                                        case 29:
5183                                                {
5184                                                setState(697);
5185                                                theadTagStart(true);
5186                                                }
5187                                                break;
5188                                        case 30:
5189                                                {
5190                                                setState(698);
5191                                                tfootTagStart(true);
5192                                                }
5193                                                break;
5194                                        case 31:
5195                                                {
5196                                                {
5197                                                setState(699);
5198                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5199                                                setState(700);
5200                                                match(LEADING_ASTERISK);
5201                                                }
5202                                                }
5203                                                break;
5204                                        case 32:
5205                                                {
5206                                                setState(701);
5207                                                htmlComment();
5208                                                }
5209                                                break;
5210                                        case 33:
5211                                                {
5212                                                setState(702);
5213                                                match(CDATA);
5214                                                }
5215                                                break;
5216                                        case 34:
5217                                                {
5218                                                setState(703);
5219                                                match(NEWLINE);
5220                                                }
5221                                                break;
5222                                        case 35:
5223                                                {
5224                                                setState(704);
5225                                                text();
5226                                                }
5227                                                break;
5228                                        case 36:
5229                                                {
5230                                                setState(705);
5231                                                javadocInlineTag();
5232                                                }
5233                                                break;
5234                                        }
5235                                        } 
5236                                }
5237                                setState(710);
5238                                _errHandler.sync(this);
5239                                _alt = getInterpreter().adaptivePredict(_input,43,_ctx);
5240                        }
5241                        setState(711);
5242                        bodyTagEnd();
5243                        }
5244                }
5245                catch (RecognitionException re) {
5246                        _localctx.exception = re;
5247                        _errHandler.reportError(this, re);
5248                        _errHandler.recover(this, re);
5249                }
5250                finally {
5251                        exitRule();
5252                }
5253                return _localctx;
5254        }
5255
5256        public static class ColgroupTagStartContext extends ParserRuleContext {
5257                public boolean isNonTight;
5258                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
5259                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5260                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
5261                public List<AttributeContext> attribute() {
5262                        return getRuleContexts(AttributeContext.class);
5263                }
5264                public AttributeContext attribute(int i) {
5265                        return getRuleContext(AttributeContext.class,i);
5266                }
5267                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5268                public TerminalNode NEWLINE(int i) {
5269                        return getToken(JavadocParser.NEWLINE, i);
5270                }
5271                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5272                public TerminalNode LEADING_ASTERISK(int i) {
5273                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5274                }
5275                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5276                public TerminalNode WS(int i) {
5277                        return getToken(JavadocParser.WS, i);
5278                }
5279                public ColgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
5280                public ColgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
5281                        super(parent, invokingState);
5282                        this.isNonTight = isNonTight;
5283                }
5284                @Override public int getRuleIndex() { return RULE_colgroupTagStart; }
5285        }
5286
5287        public final ColgroupTagStartContext colgroupTagStart(boolean isNonTight) throws RecognitionException {
5288                ColgroupTagStartContext _localctx = new ColgroupTagStartContext(_ctx, getState(), isNonTight);
5289                enterRule(_localctx, 48, RULE_colgroupTagStart);
5290                int _la;
5291                try {
5292                        enterOuterAlt(_localctx, 1);
5293                        {
5294                        setState(713);
5295                        match(START);
5296                        setState(714);
5297                        match(COLGROUP_HTML_TAG_NAME);
5298                        setState(721);
5299                        _errHandler.sync(this);
5300                        _la = _input.LA(1);
5301                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5302                                {
5303                                setState(719);
5304                                _errHandler.sync(this);
5305                                switch (_input.LA(1)) {
5306                                case HTML_TAG_NAME:
5307                                        {
5308                                        setState(715);
5309                                        attribute();
5310                                        }
5311                                        break;
5312                                case NEWLINE:
5313                                        {
5314                                        setState(716);
5315                                        match(NEWLINE);
5316                                        }
5317                                        break;
5318                                case LEADING_ASTERISK:
5319                                        {
5320                                        setState(717);
5321                                        match(LEADING_ASTERISK);
5322                                        }
5323                                        break;
5324                                case WS:
5325                                        {
5326                                        setState(718);
5327                                        match(WS);
5328                                        }
5329                                        break;
5330                                default:
5331                                        throw new NoViableAltException(this);
5332                                }
5333                                }
5334                                setState(723);
5335                                _errHandler.sync(this);
5336                                _la = _input.LA(1);
5337                        }
5338                        setState(724);
5339                        match(END);
5340                        }
5341                        _ctx.stop = _input.LT(-1);
5342
5343                            if (isNonTight && nonTightTagStartContext == null) {
5344                                nonTightTagStartContext = _localctx;
5345                            }
5346
5347                }
5348                catch (RecognitionException re) {
5349                        _localctx.exception = re;
5350                        _errHandler.reportError(this, re);
5351                        _errHandler.recover(this, re);
5352                }
5353                finally {
5354                        exitRule();
5355                }
5356                return _localctx;
5357        }
5358
5359        public static class ColgroupTagEndContext extends ParserRuleContext {
5360                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
5361                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5362                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5363                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
5364                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5365                public TerminalNode NEWLINE(int i) {
5366                        return getToken(JavadocParser.NEWLINE, i);
5367                }
5368                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5369                public TerminalNode LEADING_ASTERISK(int i) {
5370                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5371                }
5372                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5373                public TerminalNode WS(int i) {
5374                        return getToken(JavadocParser.WS, i);
5375                }
5376                public ColgroupTagEndContext(ParserRuleContext parent, int invokingState) {
5377                        super(parent, invokingState);
5378                }
5379                @Override public int getRuleIndex() { return RULE_colgroupTagEnd; }
5380        }
5381
5382        public final ColgroupTagEndContext colgroupTagEnd() throws RecognitionException {
5383                ColgroupTagEndContext _localctx = new ColgroupTagEndContext(_ctx, getState());
5384                enterRule(_localctx, 50, RULE_colgroupTagEnd);
5385                int _la;
5386                try {
5387                        enterOuterAlt(_localctx, 1);
5388                        {
5389                        setState(726);
5390                        match(START);
5391                        setState(727);
5392                        match(SLASH);
5393                        setState(728);
5394                        match(COLGROUP_HTML_TAG_NAME);
5395                        setState(732);
5396                        _errHandler.sync(this);
5397                        _la = _input.LA(1);
5398                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5399                                {
5400                                {
5401                                setState(729);
5402                                _la = _input.LA(1);
5403                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5404                                _errHandler.recoverInline(this);
5405                                }
5406                                else {
5407                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
5408                                        _errHandler.reportMatch(this);
5409                                        consume();
5410                                }
5411                                }
5412                                }
5413                                setState(734);
5414                                _errHandler.sync(this);
5415                                _la = _input.LA(1);
5416                        }
5417                        setState(735);
5418                        match(END);
5419                        }
5420                }
5421                catch (RecognitionException re) {
5422                        _localctx.exception = re;
5423                        _errHandler.reportError(this, re);
5424                        _errHandler.recover(this, re);
5425                }
5426                finally {
5427                        exitRule();
5428                }
5429                return _localctx;
5430        }
5431
5432        public static class ColgroupContext extends ParserRuleContext {
5433                public ColgroupTagStartContext colgroupTagStart() {
5434                        return getRuleContext(ColgroupTagStartContext.class,0);
5435                }
5436                public ColgroupTagEndContext colgroupTagEnd() {
5437                        return getRuleContext(ColgroupTagEndContext.class,0);
5438                }
5439                public List<HtmlTagContext> htmlTag() {
5440                        return getRuleContexts(HtmlTagContext.class);
5441                }
5442                public HtmlTagContext htmlTag(int i) {
5443                        return getRuleContext(HtmlTagContext.class,i);
5444                }
5445                public List<SingletonElementContext> singletonElement() {
5446                        return getRuleContexts(SingletonElementContext.class);
5447                }
5448                public SingletonElementContext singletonElement(int i) {
5449                        return getRuleContext(SingletonElementContext.class,i);
5450                }
5451                public List<ParagraphContext> paragraph() {
5452                        return getRuleContexts(ParagraphContext.class);
5453                }
5454                public ParagraphContext paragraph(int i) {
5455                        return getRuleContext(ParagraphContext.class,i);
5456                }
5457                public List<LiContext> li() {
5458                        return getRuleContexts(LiContext.class);
5459                }
5460                public LiContext li(int i) {
5461                        return getRuleContext(LiContext.class,i);
5462                }
5463                public List<TrContext> tr() {
5464                        return getRuleContexts(TrContext.class);
5465                }
5466                public TrContext tr(int i) {
5467                        return getRuleContext(TrContext.class,i);
5468                }
5469                public List<TdContext> td() {
5470                        return getRuleContexts(TdContext.class);
5471                }
5472                public TdContext td(int i) {
5473                        return getRuleContext(TdContext.class,i);
5474                }
5475                public List<ThContext> th() {
5476                        return getRuleContexts(ThContext.class);
5477                }
5478                public ThContext th(int i) {
5479                        return getRuleContext(ThContext.class,i);
5480                }
5481                public List<BodyContext> body() {
5482                        return getRuleContexts(BodyContext.class);
5483                }
5484                public BodyContext body(int i) {
5485                        return getRuleContext(BodyContext.class,i);
5486                }
5487                public List<DdContext> dd() {
5488                        return getRuleContexts(DdContext.class);
5489                }
5490                public DdContext dd(int i) {
5491                        return getRuleContext(DdContext.class,i);
5492                }
5493                public List<DtContext> dt() {
5494                        return getRuleContexts(DtContext.class);
5495                }
5496                public DtContext dt(int i) {
5497                        return getRuleContext(DtContext.class,i);
5498                }
5499                public List<HeadContext> head() {
5500                        return getRuleContexts(HeadContext.class);
5501                }
5502                public HeadContext head(int i) {
5503                        return getRuleContext(HeadContext.class,i);
5504                }
5505                public List<HtmlContext> html() {
5506                        return getRuleContexts(HtmlContext.class);
5507                }
5508                public HtmlContext html(int i) {
5509                        return getRuleContext(HtmlContext.class,i);
5510                }
5511                public List<OptionContext> option() {
5512                        return getRuleContexts(OptionContext.class);
5513                }
5514                public OptionContext option(int i) {
5515                        return getRuleContext(OptionContext.class,i);
5516                }
5517                public List<TbodyContext> tbody() {
5518                        return getRuleContexts(TbodyContext.class);
5519                }
5520                public TbodyContext tbody(int i) {
5521                        return getRuleContext(TbodyContext.class,i);
5522                }
5523                public List<TheadContext> thead() {
5524                        return getRuleContexts(TheadContext.class);
5525                }
5526                public TheadContext thead(int i) {
5527                        return getRuleContext(TheadContext.class,i);
5528                }
5529                public List<TfootContext> tfoot() {
5530                        return getRuleContexts(TfootContext.class);
5531                }
5532                public TfootContext tfoot(int i) {
5533                        return getRuleContext(TfootContext.class,i);
5534                }
5535                public List<PTagStartContext> pTagStart() {
5536                        return getRuleContexts(PTagStartContext.class);
5537                }
5538                public PTagStartContext pTagStart(int i) {
5539                        return getRuleContext(PTagStartContext.class,i);
5540                }
5541                public List<LiTagStartContext> liTagStart() {
5542                        return getRuleContexts(LiTagStartContext.class);
5543                }
5544                public LiTagStartContext liTagStart(int i) {
5545                        return getRuleContext(LiTagStartContext.class,i);
5546                }
5547                public List<TrTagStartContext> trTagStart() {
5548                        return getRuleContexts(TrTagStartContext.class);
5549                }
5550                public TrTagStartContext trTagStart(int i) {
5551                        return getRuleContext(TrTagStartContext.class,i);
5552                }
5553                public List<TdTagStartContext> tdTagStart() {
5554                        return getRuleContexts(TdTagStartContext.class);
5555                }
5556                public TdTagStartContext tdTagStart(int i) {
5557                        return getRuleContext(TdTagStartContext.class,i);
5558                }
5559                public List<ThTagStartContext> thTagStart() {
5560                        return getRuleContexts(ThTagStartContext.class);
5561                }
5562                public ThTagStartContext thTagStart(int i) {
5563                        return getRuleContext(ThTagStartContext.class,i);
5564                }
5565                public List<BodyTagStartContext> bodyTagStart() {
5566                        return getRuleContexts(BodyTagStartContext.class);
5567                }
5568                public BodyTagStartContext bodyTagStart(int i) {
5569                        return getRuleContext(BodyTagStartContext.class,i);
5570                }
5571                public List<DdTagStartContext> ddTagStart() {
5572                        return getRuleContexts(DdTagStartContext.class);
5573                }
5574                public DdTagStartContext ddTagStart(int i) {
5575                        return getRuleContext(DdTagStartContext.class,i);
5576                }
5577                public List<DtTagStartContext> dtTagStart() {
5578                        return getRuleContexts(DtTagStartContext.class);
5579                }
5580                public DtTagStartContext dtTagStart(int i) {
5581                        return getRuleContext(DtTagStartContext.class,i);
5582                }
5583                public List<HeadTagStartContext> headTagStart() {
5584                        return getRuleContexts(HeadTagStartContext.class);
5585                }
5586                public HeadTagStartContext headTagStart(int i) {
5587                        return getRuleContext(HeadTagStartContext.class,i);
5588                }
5589                public List<HtmlTagStartContext> htmlTagStart() {
5590                        return getRuleContexts(HtmlTagStartContext.class);
5591                }
5592                public HtmlTagStartContext htmlTagStart(int i) {
5593                        return getRuleContext(HtmlTagStartContext.class,i);
5594                }
5595                public List<OptionTagStartContext> optionTagStart() {
5596                        return getRuleContexts(OptionTagStartContext.class);
5597                }
5598                public OptionTagStartContext optionTagStart(int i) {
5599                        return getRuleContext(OptionTagStartContext.class,i);
5600                }
5601                public List<TbodyTagStartContext> tbodyTagStart() {
5602                        return getRuleContexts(TbodyTagStartContext.class);
5603                }
5604                public TbodyTagStartContext tbodyTagStart(int i) {
5605                        return getRuleContext(TbodyTagStartContext.class,i);
5606                }
5607                public List<TheadTagStartContext> theadTagStart() {
5608                        return getRuleContexts(TheadTagStartContext.class);
5609                }
5610                public TheadTagStartContext theadTagStart(int i) {
5611                        return getRuleContext(TheadTagStartContext.class,i);
5612                }
5613                public List<TfootTagStartContext> tfootTagStart() {
5614                        return getRuleContexts(TfootTagStartContext.class);
5615                }
5616                public TfootTagStartContext tfootTagStart(int i) {
5617                        return getRuleContext(TfootTagStartContext.class,i);
5618                }
5619                public List<HtmlCommentContext> htmlComment() {
5620                        return getRuleContexts(HtmlCommentContext.class);
5621                }
5622                public HtmlCommentContext htmlComment(int i) {
5623                        return getRuleContext(HtmlCommentContext.class,i);
5624                }
5625                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5626                public TerminalNode CDATA(int i) {
5627                        return getToken(JavadocParser.CDATA, i);
5628                }
5629                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5630                public TerminalNode NEWLINE(int i) {
5631                        return getToken(JavadocParser.NEWLINE, i);
5632                }
5633                public List<TextContext> text() {
5634                        return getRuleContexts(TextContext.class);
5635                }
5636                public TextContext text(int i) {
5637                        return getRuleContext(TextContext.class,i);
5638                }
5639                public List<JavadocInlineTagContext> javadocInlineTag() {
5640                        return getRuleContexts(JavadocInlineTagContext.class);
5641                }
5642                public JavadocInlineTagContext javadocInlineTag(int i) {
5643                        return getRuleContext(JavadocInlineTagContext.class,i);
5644                }
5645                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5646                public TerminalNode LEADING_ASTERISK(int i) {
5647                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5648                }
5649                public ColgroupContext(ParserRuleContext parent, int invokingState) {
5650                        super(parent, invokingState);
5651                }
5652                @Override public int getRuleIndex() { return RULE_colgroup; }
5653        }
5654
5655        public final ColgroupContext colgroup() throws RecognitionException {
5656                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
5657                enterRule(_localctx, 52, RULE_colgroup);
5658                try {
5659                        int _alt;
5660                        enterOuterAlt(_localctx, 1);
5661                        {
5662                        setState(737);
5663                        colgroupTagStart(false);
5664                        setState(777);
5665                        _errHandler.sync(this);
5666                        _alt = getInterpreter().adaptivePredict(_input,48,_ctx);
5667                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5668                                if ( _alt==1 ) {
5669                                        {
5670                                        setState(775);
5671                                        _errHandler.sync(this);
5672                                        switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
5673                                        case 1:
5674                                                {
5675                                                setState(738);
5676                                                htmlTag();
5677                                                }
5678                                                break;
5679                                        case 2:
5680                                                {
5681                                                setState(739);
5682                                                singletonElement();
5683                                                }
5684                                                break;
5685                                        case 3:
5686                                                {
5687                                                setState(740);
5688                                                paragraph();
5689                                                }
5690                                                break;
5691                                        case 4:
5692                                                {
5693                                                setState(741);
5694                                                li();
5695                                                }
5696                                                break;
5697                                        case 5:
5698                                                {
5699                                                setState(742);
5700                                                tr();
5701                                                }
5702                                                break;
5703                                        case 6:
5704                                                {
5705                                                setState(743);
5706                                                td();
5707                                                }
5708                                                break;
5709                                        case 7:
5710                                                {
5711                                                setState(744);
5712                                                th();
5713                                                }
5714                                                break;
5715                                        case 8:
5716                                                {
5717                                                setState(745);
5718                                                body();
5719                                                }
5720                                                break;
5721                                        case 9:
5722                                                {
5723                                                setState(746);
5724                                                dd();
5725                                                }
5726                                                break;
5727                                        case 10:
5728                                                {
5729                                                setState(747);
5730                                                dt();
5731                                                }
5732                                                break;
5733                                        case 11:
5734                                                {
5735                                                setState(748);
5736                                                head();
5737                                                }
5738                                                break;
5739                                        case 12:
5740                                                {
5741                                                setState(749);
5742                                                html();
5743                                                }
5744                                                break;
5745                                        case 13:
5746                                                {
5747                                                setState(750);
5748                                                option();
5749                                                }
5750                                                break;
5751                                        case 14:
5752                                                {
5753                                                setState(751);
5754                                                tbody();
5755                                                }
5756                                                break;
5757                                        case 15:
5758                                                {
5759                                                setState(752);
5760                                                thead();
5761                                                }
5762                                                break;
5763                                        case 16:
5764                                                {
5765                                                setState(753);
5766                                                tfoot();
5767                                                }
5768                                                break;
5769                                        case 17:
5770                                                {
5771                                                setState(754);
5772                                                pTagStart(true);
5773                                                }
5774                                                break;
5775                                        case 18:
5776                                                {
5777                                                setState(755);
5778                                                liTagStart(true);
5779                                                }
5780                                                break;
5781                                        case 19:
5782                                                {
5783                                                setState(756);
5784                                                trTagStart(true);
5785                                                }
5786                                                break;
5787                                        case 20:
5788                                                {
5789                                                setState(757);
5790                                                tdTagStart(true);
5791                                                }
5792                                                break;
5793                                        case 21:
5794                                                {
5795                                                setState(758);
5796                                                thTagStart(true);
5797                                                }
5798                                                break;
5799                                        case 22:
5800                                                {
5801                                                setState(759);
5802                                                bodyTagStart(true);
5803                                                }
5804                                                break;
5805                                        case 23:
5806                                                {
5807                                                setState(760);
5808                                                ddTagStart(true);
5809                                                }
5810                                                break;
5811                                        case 24:
5812                                                {
5813                                                setState(761);
5814                                                dtTagStart(true);
5815                                                }
5816                                                break;
5817                                        case 25:
5818                                                {
5819                                                setState(762);
5820                                                headTagStart(true);
5821                                                }
5822                                                break;
5823                                        case 26:
5824                                                {
5825                                                setState(763);
5826                                                htmlTagStart(true);
5827                                                }
5828                                                break;
5829                                        case 27:
5830                                                {
5831                                                setState(764);
5832                                                optionTagStart(true);
5833                                                }
5834                                                break;
5835                                        case 28:
5836                                                {
5837                                                setState(765);
5838                                                tbodyTagStart(true);
5839                                                }
5840                                                break;
5841                                        case 29:
5842                                                {
5843                                                setState(766);
5844                                                theadTagStart(true);
5845                                                }
5846                                                break;
5847                                        case 30:
5848                                                {
5849                                                setState(767);
5850                                                tfootTagStart(true);
5851                                                }
5852                                                break;
5853                                        case 31:
5854                                                {
5855                                                {
5856                                                setState(768);
5857                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5858                                                setState(769);
5859                                                match(LEADING_ASTERISK);
5860                                                }
5861                                                }
5862                                                break;
5863                                        case 32:
5864                                                {
5865                                                setState(770);
5866                                                htmlComment();
5867                                                }
5868                                                break;
5869                                        case 33:
5870                                                {
5871                                                setState(771);
5872                                                match(CDATA);
5873                                                }
5874                                                break;
5875                                        case 34:
5876                                                {
5877                                                setState(772);
5878                                                match(NEWLINE);
5879                                                }
5880                                                break;
5881                                        case 35:
5882                                                {
5883                                                setState(773);
5884                                                text();
5885                                                }
5886                                                break;
5887                                        case 36:
5888                                                {
5889                                                setState(774);
5890                                                javadocInlineTag();
5891                                                }
5892                                                break;
5893                                        }
5894                                        } 
5895                                }
5896                                setState(779);
5897                                _errHandler.sync(this);
5898                                _alt = getInterpreter().adaptivePredict(_input,48,_ctx);
5899                        }
5900                        setState(780);
5901                        colgroupTagEnd();
5902                        }
5903                }
5904                catch (RecognitionException re) {
5905                        _localctx.exception = re;
5906                        _errHandler.reportError(this, re);
5907                        _errHandler.recover(this, re);
5908                }
5909                finally {
5910                        exitRule();
5911                }
5912                return _localctx;
5913        }
5914
5915        public static class DdTagStartContext extends ParserRuleContext {
5916                public boolean isNonTight;
5917                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
5918                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
5919                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
5920                public List<AttributeContext> attribute() {
5921                        return getRuleContexts(AttributeContext.class);
5922                }
5923                public AttributeContext attribute(int i) {
5924                        return getRuleContext(AttributeContext.class,i);
5925                }
5926                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5927                public TerminalNode NEWLINE(int i) {
5928                        return getToken(JavadocParser.NEWLINE, i);
5929                }
5930                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5931                public TerminalNode LEADING_ASTERISK(int i) {
5932                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5933                }
5934                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5935                public TerminalNode WS(int i) {
5936                        return getToken(JavadocParser.WS, i);
5937                }
5938                public DdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
5939                public DdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
5940                        super(parent, invokingState);
5941                        this.isNonTight = isNonTight;
5942                }
5943                @Override public int getRuleIndex() { return RULE_ddTagStart; }
5944        }
5945
5946        public final DdTagStartContext ddTagStart(boolean isNonTight) throws RecognitionException {
5947                DdTagStartContext _localctx = new DdTagStartContext(_ctx, getState(), isNonTight);
5948                enterRule(_localctx, 54, RULE_ddTagStart);
5949                int _la;
5950                try {
5951                        enterOuterAlt(_localctx, 1);
5952                        {
5953                        setState(782);
5954                        match(START);
5955                        setState(783);
5956                        match(DD_HTML_TAG_NAME);
5957                        setState(790);
5958                        _errHandler.sync(this);
5959                        _la = _input.LA(1);
5960                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5961                                {
5962                                setState(788);
5963                                _errHandler.sync(this);
5964                                switch (_input.LA(1)) {
5965                                case HTML_TAG_NAME:
5966                                        {
5967                                        setState(784);
5968                                        attribute();
5969                                        }
5970                                        break;
5971                                case NEWLINE:
5972                                        {
5973                                        setState(785);
5974                                        match(NEWLINE);
5975                                        }
5976                                        break;
5977                                case LEADING_ASTERISK:
5978                                        {
5979                                        setState(786);
5980                                        match(LEADING_ASTERISK);
5981                                        }
5982                                        break;
5983                                case WS:
5984                                        {
5985                                        setState(787);
5986                                        match(WS);
5987                                        }
5988                                        break;
5989                                default:
5990                                        throw new NoViableAltException(this);
5991                                }
5992                                }
5993                                setState(792);
5994                                _errHandler.sync(this);
5995                                _la = _input.LA(1);
5996                        }
5997                        setState(793);
5998                        match(END);
5999                        }
6000                        _ctx.stop = _input.LT(-1);
6001
6002                            if (isNonTight && nonTightTagStartContext == null) {
6003                                nonTightTagStartContext = _localctx;
6004                            }
6005
6006                }
6007                catch (RecognitionException re) {
6008                        _localctx.exception = re;
6009                        _errHandler.reportError(this, re);
6010                        _errHandler.recover(this, re);
6011                }
6012                finally {
6013                        exitRule();
6014                }
6015                return _localctx;
6016        }
6017
6018        public static class DdTagEndContext extends ParserRuleContext {
6019                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
6020                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6021                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6022                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
6023                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6024                public TerminalNode NEWLINE(int i) {
6025                        return getToken(JavadocParser.NEWLINE, i);
6026                }
6027                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6028                public TerminalNode LEADING_ASTERISK(int i) {
6029                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6030                }
6031                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6032                public TerminalNode WS(int i) {
6033                        return getToken(JavadocParser.WS, i);
6034                }
6035                public DdTagEndContext(ParserRuleContext parent, int invokingState) {
6036                        super(parent, invokingState);
6037                }
6038                @Override public int getRuleIndex() { return RULE_ddTagEnd; }
6039        }
6040
6041        public final DdTagEndContext ddTagEnd() throws RecognitionException {
6042                DdTagEndContext _localctx = new DdTagEndContext(_ctx, getState());
6043                enterRule(_localctx, 56, RULE_ddTagEnd);
6044                int _la;
6045                try {
6046                        enterOuterAlt(_localctx, 1);
6047                        {
6048                        setState(795);
6049                        match(START);
6050                        setState(796);
6051                        match(SLASH);
6052                        setState(797);
6053                        match(DD_HTML_TAG_NAME);
6054                        setState(801);
6055                        _errHandler.sync(this);
6056                        _la = _input.LA(1);
6057                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6058                                {
6059                                {
6060                                setState(798);
6061                                _la = _input.LA(1);
6062                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6063                                _errHandler.recoverInline(this);
6064                                }
6065                                else {
6066                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
6067                                        _errHandler.reportMatch(this);
6068                                        consume();
6069                                }
6070                                }
6071                                }
6072                                setState(803);
6073                                _errHandler.sync(this);
6074                                _la = _input.LA(1);
6075                        }
6076                        setState(804);
6077                        match(END);
6078                        }
6079                }
6080                catch (RecognitionException re) {
6081                        _localctx.exception = re;
6082                        _errHandler.reportError(this, re);
6083                        _errHandler.recover(this, re);
6084                }
6085                finally {
6086                        exitRule();
6087                }
6088                return _localctx;
6089        }
6090
6091        public static class DdContext extends ParserRuleContext {
6092                public DdTagStartContext ddTagStart() {
6093                        return getRuleContext(DdTagStartContext.class,0);
6094                }
6095                public DdTagEndContext ddTagEnd() {
6096                        return getRuleContext(DdTagEndContext.class,0);
6097                }
6098                public List<HtmlTagContext> htmlTag() {
6099                        return getRuleContexts(HtmlTagContext.class);
6100                }
6101                public HtmlTagContext htmlTag(int i) {
6102                        return getRuleContext(HtmlTagContext.class,i);
6103                }
6104                public List<SingletonElementContext> singletonElement() {
6105                        return getRuleContexts(SingletonElementContext.class);
6106                }
6107                public SingletonElementContext singletonElement(int i) {
6108                        return getRuleContext(SingletonElementContext.class,i);
6109                }
6110                public List<ParagraphContext> paragraph() {
6111                        return getRuleContexts(ParagraphContext.class);
6112                }
6113                public ParagraphContext paragraph(int i) {
6114                        return getRuleContext(ParagraphContext.class,i);
6115                }
6116                public List<LiContext> li() {
6117                        return getRuleContexts(LiContext.class);
6118                }
6119                public LiContext li(int i) {
6120                        return getRuleContext(LiContext.class,i);
6121                }
6122                public List<TrContext> tr() {
6123                        return getRuleContexts(TrContext.class);
6124                }
6125                public TrContext tr(int i) {
6126                        return getRuleContext(TrContext.class,i);
6127                }
6128                public List<TdContext> td() {
6129                        return getRuleContexts(TdContext.class);
6130                }
6131                public TdContext td(int i) {
6132                        return getRuleContext(TdContext.class,i);
6133                }
6134                public List<ThContext> th() {
6135                        return getRuleContexts(ThContext.class);
6136                }
6137                public ThContext th(int i) {
6138                        return getRuleContext(ThContext.class,i);
6139                }
6140                public List<BodyContext> body() {
6141                        return getRuleContexts(BodyContext.class);
6142                }
6143                public BodyContext body(int i) {
6144                        return getRuleContext(BodyContext.class,i);
6145                }
6146                public List<ColgroupContext> colgroup() {
6147                        return getRuleContexts(ColgroupContext.class);
6148                }
6149                public ColgroupContext colgroup(int i) {
6150                        return getRuleContext(ColgroupContext.class,i);
6151                }
6152                public List<DtContext> dt() {
6153                        return getRuleContexts(DtContext.class);
6154                }
6155                public DtContext dt(int i) {
6156                        return getRuleContext(DtContext.class,i);
6157                }
6158                public List<HeadContext> head() {
6159                        return getRuleContexts(HeadContext.class);
6160                }
6161                public HeadContext head(int i) {
6162                        return getRuleContext(HeadContext.class,i);
6163                }
6164                public List<HtmlContext> html() {
6165                        return getRuleContexts(HtmlContext.class);
6166                }
6167                public HtmlContext html(int i) {
6168                        return getRuleContext(HtmlContext.class,i);
6169                }
6170                public List<OptionContext> option() {
6171                        return getRuleContexts(OptionContext.class);
6172                }
6173                public OptionContext option(int i) {
6174                        return getRuleContext(OptionContext.class,i);
6175                }
6176                public List<TbodyContext> tbody() {
6177                        return getRuleContexts(TbodyContext.class);
6178                }
6179                public TbodyContext tbody(int i) {
6180                        return getRuleContext(TbodyContext.class,i);
6181                }
6182                public List<TheadContext> thead() {
6183                        return getRuleContexts(TheadContext.class);
6184                }
6185                public TheadContext thead(int i) {
6186                        return getRuleContext(TheadContext.class,i);
6187                }
6188                public List<TfootContext> tfoot() {
6189                        return getRuleContexts(TfootContext.class);
6190                }
6191                public TfootContext tfoot(int i) {
6192                        return getRuleContext(TfootContext.class,i);
6193                }
6194                public List<PTagStartContext> pTagStart() {
6195                        return getRuleContexts(PTagStartContext.class);
6196                }
6197                public PTagStartContext pTagStart(int i) {
6198                        return getRuleContext(PTagStartContext.class,i);
6199                }
6200                public List<LiTagStartContext> liTagStart() {
6201                        return getRuleContexts(LiTagStartContext.class);
6202                }
6203                public LiTagStartContext liTagStart(int i) {
6204                        return getRuleContext(LiTagStartContext.class,i);
6205                }
6206                public List<TrTagStartContext> trTagStart() {
6207                        return getRuleContexts(TrTagStartContext.class);
6208                }
6209                public TrTagStartContext trTagStart(int i) {
6210                        return getRuleContext(TrTagStartContext.class,i);
6211                }
6212                public List<TdTagStartContext> tdTagStart() {
6213                        return getRuleContexts(TdTagStartContext.class);
6214                }
6215                public TdTagStartContext tdTagStart(int i) {
6216                        return getRuleContext(TdTagStartContext.class,i);
6217                }
6218                public List<ThTagStartContext> thTagStart() {
6219                        return getRuleContexts(ThTagStartContext.class);
6220                }
6221                public ThTagStartContext thTagStart(int i) {
6222                        return getRuleContext(ThTagStartContext.class,i);
6223                }
6224                public List<BodyTagStartContext> bodyTagStart() {
6225                        return getRuleContexts(BodyTagStartContext.class);
6226                }
6227                public BodyTagStartContext bodyTagStart(int i) {
6228                        return getRuleContext(BodyTagStartContext.class,i);
6229                }
6230                public List<ColgroupTagStartContext> colgroupTagStart() {
6231                        return getRuleContexts(ColgroupTagStartContext.class);
6232                }
6233                public ColgroupTagStartContext colgroupTagStart(int i) {
6234                        return getRuleContext(ColgroupTagStartContext.class,i);
6235                }
6236                public List<DtTagStartContext> dtTagStart() {
6237                        return getRuleContexts(DtTagStartContext.class);
6238                }
6239                public DtTagStartContext dtTagStart(int i) {
6240                        return getRuleContext(DtTagStartContext.class,i);
6241                }
6242                public List<HeadTagStartContext> headTagStart() {
6243                        return getRuleContexts(HeadTagStartContext.class);
6244                }
6245                public HeadTagStartContext headTagStart(int i) {
6246                        return getRuleContext(HeadTagStartContext.class,i);
6247                }
6248                public List<HtmlTagStartContext> htmlTagStart() {
6249                        return getRuleContexts(HtmlTagStartContext.class);
6250                }
6251                public HtmlTagStartContext htmlTagStart(int i) {
6252                        return getRuleContext(HtmlTagStartContext.class,i);
6253                }
6254                public List<OptionTagStartContext> optionTagStart() {
6255                        return getRuleContexts(OptionTagStartContext.class);
6256                }
6257                public OptionTagStartContext optionTagStart(int i) {
6258                        return getRuleContext(OptionTagStartContext.class,i);
6259                }
6260                public List<TbodyTagStartContext> tbodyTagStart() {
6261                        return getRuleContexts(TbodyTagStartContext.class);
6262                }
6263                public TbodyTagStartContext tbodyTagStart(int i) {
6264                        return getRuleContext(TbodyTagStartContext.class,i);
6265                }
6266                public List<TheadTagStartContext> theadTagStart() {
6267                        return getRuleContexts(TheadTagStartContext.class);
6268                }
6269                public TheadTagStartContext theadTagStart(int i) {
6270                        return getRuleContext(TheadTagStartContext.class,i);
6271                }
6272                public List<TfootTagStartContext> tfootTagStart() {
6273                        return getRuleContexts(TfootTagStartContext.class);
6274                }
6275                public TfootTagStartContext tfootTagStart(int i) {
6276                        return getRuleContext(TfootTagStartContext.class,i);
6277                }
6278                public List<HtmlCommentContext> htmlComment() {
6279                        return getRuleContexts(HtmlCommentContext.class);
6280                }
6281                public HtmlCommentContext htmlComment(int i) {
6282                        return getRuleContext(HtmlCommentContext.class,i);
6283                }
6284                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6285                public TerminalNode CDATA(int i) {
6286                        return getToken(JavadocParser.CDATA, i);
6287                }
6288                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6289                public TerminalNode NEWLINE(int i) {
6290                        return getToken(JavadocParser.NEWLINE, i);
6291                }
6292                public List<TextContext> text() {
6293                        return getRuleContexts(TextContext.class);
6294                }
6295                public TextContext text(int i) {
6296                        return getRuleContext(TextContext.class,i);
6297                }
6298                public List<JavadocInlineTagContext> javadocInlineTag() {
6299                        return getRuleContexts(JavadocInlineTagContext.class);
6300                }
6301                public JavadocInlineTagContext javadocInlineTag(int i) {
6302                        return getRuleContext(JavadocInlineTagContext.class,i);
6303                }
6304                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6305                public TerminalNode LEADING_ASTERISK(int i) {
6306                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6307                }
6308                public DdContext(ParserRuleContext parent, int invokingState) {
6309                        super(parent, invokingState);
6310                }
6311                @Override public int getRuleIndex() { return RULE_dd; }
6312        }
6313
6314        public final DdContext dd() throws RecognitionException {
6315                DdContext _localctx = new DdContext(_ctx, getState());
6316                enterRule(_localctx, 58, RULE_dd);
6317                try {
6318                        int _alt;
6319                        enterOuterAlt(_localctx, 1);
6320                        {
6321                        setState(806);
6322                        ddTagStart(false);
6323                        setState(846);
6324                        _errHandler.sync(this);
6325                        _alt = getInterpreter().adaptivePredict(_input,53,_ctx);
6326                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6327                                if ( _alt==1 ) {
6328                                        {
6329                                        setState(844);
6330                                        _errHandler.sync(this);
6331                                        switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
6332                                        case 1:
6333                                                {
6334                                                setState(807);
6335                                                htmlTag();
6336                                                }
6337                                                break;
6338                                        case 2:
6339                                                {
6340                                                setState(808);
6341                                                singletonElement();
6342                                                }
6343                                                break;
6344                                        case 3:
6345                                                {
6346                                                setState(809);
6347                                                paragraph();
6348                                                }
6349                                                break;
6350                                        case 4:
6351                                                {
6352                                                setState(810);
6353                                                li();
6354                                                }
6355                                                break;
6356                                        case 5:
6357                                                {
6358                                                setState(811);
6359                                                tr();
6360                                                }
6361                                                break;
6362                                        case 6:
6363                                                {
6364                                                setState(812);
6365                                                td();
6366                                                }
6367                                                break;
6368                                        case 7:
6369                                                {
6370                                                setState(813);
6371                                                th();
6372                                                }
6373                                                break;
6374                                        case 8:
6375                                                {
6376                                                setState(814);
6377                                                body();
6378                                                }
6379                                                break;
6380                                        case 9:
6381                                                {
6382                                                setState(815);
6383                                                colgroup();
6384                                                }
6385                                                break;
6386                                        case 10:
6387                                                {
6388                                                setState(816);
6389                                                dt();
6390                                                }
6391                                                break;
6392                                        case 11:
6393                                                {
6394                                                setState(817);
6395                                                head();
6396                                                }
6397                                                break;
6398                                        case 12:
6399                                                {
6400                                                setState(818);
6401                                                html();
6402                                                }
6403                                                break;
6404                                        case 13:
6405                                                {
6406                                                setState(819);
6407                                                option();
6408                                                }
6409                                                break;
6410                                        case 14:
6411                                                {
6412                                                setState(820);
6413                                                tbody();
6414                                                }
6415                                                break;
6416                                        case 15:
6417                                                {
6418                                                setState(821);
6419                                                thead();
6420                                                }
6421                                                break;
6422                                        case 16:
6423                                                {
6424                                                setState(822);
6425                                                tfoot();
6426                                                }
6427                                                break;
6428                                        case 17:
6429                                                {
6430                                                setState(823);
6431                                                pTagStart(true);
6432                                                }
6433                                                break;
6434                                        case 18:
6435                                                {
6436                                                setState(824);
6437                                                liTagStart(true);
6438                                                }
6439                                                break;
6440                                        case 19:
6441                                                {
6442                                                setState(825);
6443                                                trTagStart(true);
6444                                                }
6445                                                break;
6446                                        case 20:
6447                                                {
6448                                                setState(826);
6449                                                tdTagStart(true);
6450                                                }
6451                                                break;
6452                                        case 21:
6453                                                {
6454                                                setState(827);
6455                                                thTagStart(true);
6456                                                }
6457                                                break;
6458                                        case 22:
6459                                                {
6460                                                setState(828);
6461                                                bodyTagStart(true);
6462                                                }
6463                                                break;
6464                                        case 23:
6465                                                {
6466                                                setState(829);
6467                                                colgroupTagStart(true);
6468                                                }
6469                                                break;
6470                                        case 24:
6471                                                {
6472                                                setState(830);
6473                                                dtTagStart(true);
6474                                                }
6475                                                break;
6476                                        case 25:
6477                                                {
6478                                                setState(831);
6479                                                headTagStart(true);
6480                                                }
6481                                                break;
6482                                        case 26:
6483                                                {
6484                                                setState(832);
6485                                                htmlTagStart(true);
6486                                                }
6487                                                break;
6488                                        case 27:
6489                                                {
6490                                                setState(833);
6491                                                optionTagStart(true);
6492                                                }
6493                                                break;
6494                                        case 28:
6495                                                {
6496                                                setState(834);
6497                                                tbodyTagStart(true);
6498                                                }
6499                                                break;
6500                                        case 29:
6501                                                {
6502                                                setState(835);
6503                                                theadTagStart(true);
6504                                                }
6505                                                break;
6506                                        case 30:
6507                                                {
6508                                                setState(836);
6509                                                tfootTagStart(true);
6510                                                }
6511                                                break;
6512                                        case 31:
6513                                                {
6514                                                {
6515                                                setState(837);
6516                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6517                                                setState(838);
6518                                                match(LEADING_ASTERISK);
6519                                                }
6520                                                }
6521                                                break;
6522                                        case 32:
6523                                                {
6524                                                setState(839);
6525                                                htmlComment();
6526                                                }
6527                                                break;
6528                                        case 33:
6529                                                {
6530                                                setState(840);
6531                                                match(CDATA);
6532                                                }
6533                                                break;
6534                                        case 34:
6535                                                {
6536                                                setState(841);
6537                                                match(NEWLINE);
6538                                                }
6539                                                break;
6540                                        case 35:
6541                                                {
6542                                                setState(842);
6543                                                text();
6544                                                }
6545                                                break;
6546                                        case 36:
6547                                                {
6548                                                setState(843);
6549                                                javadocInlineTag();
6550                                                }
6551                                                break;
6552                                        }
6553                                        } 
6554                                }
6555                                setState(848);
6556                                _errHandler.sync(this);
6557                                _alt = getInterpreter().adaptivePredict(_input,53,_ctx);
6558                        }
6559                        setState(849);
6560                        ddTagEnd();
6561                        }
6562                }
6563                catch (RecognitionException re) {
6564                        _localctx.exception = re;
6565                        _errHandler.reportError(this, re);
6566                        _errHandler.recover(this, re);
6567                }
6568                finally {
6569                        exitRule();
6570                }
6571                return _localctx;
6572        }
6573
6574        public static class DtTagStartContext extends ParserRuleContext {
6575                public boolean isNonTight;
6576                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
6577                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6578                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
6579                public List<AttributeContext> attribute() {
6580                        return getRuleContexts(AttributeContext.class);
6581                }
6582                public AttributeContext attribute(int i) {
6583                        return getRuleContext(AttributeContext.class,i);
6584                }
6585                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6586                public TerminalNode NEWLINE(int i) {
6587                        return getToken(JavadocParser.NEWLINE, i);
6588                }
6589                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6590                public TerminalNode LEADING_ASTERISK(int i) {
6591                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6592                }
6593                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6594                public TerminalNode WS(int i) {
6595                        return getToken(JavadocParser.WS, i);
6596                }
6597                public DtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
6598                public DtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
6599                        super(parent, invokingState);
6600                        this.isNonTight = isNonTight;
6601                }
6602                @Override public int getRuleIndex() { return RULE_dtTagStart; }
6603        }
6604
6605        public final DtTagStartContext dtTagStart(boolean isNonTight) throws RecognitionException {
6606                DtTagStartContext _localctx = new DtTagStartContext(_ctx, getState(), isNonTight);
6607                enterRule(_localctx, 60, RULE_dtTagStart);
6608                int _la;
6609                try {
6610                        enterOuterAlt(_localctx, 1);
6611                        {
6612                        setState(851);
6613                        match(START);
6614                        setState(852);
6615                        match(DT_HTML_TAG_NAME);
6616                        setState(859);
6617                        _errHandler.sync(this);
6618                        _la = _input.LA(1);
6619                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6620                                {
6621                                setState(857);
6622                                _errHandler.sync(this);
6623                                switch (_input.LA(1)) {
6624                                case HTML_TAG_NAME:
6625                                        {
6626                                        setState(853);
6627                                        attribute();
6628                                        }
6629                                        break;
6630                                case NEWLINE:
6631                                        {
6632                                        setState(854);
6633                                        match(NEWLINE);
6634                                        }
6635                                        break;
6636                                case LEADING_ASTERISK:
6637                                        {
6638                                        setState(855);
6639                                        match(LEADING_ASTERISK);
6640                                        }
6641                                        break;
6642                                case WS:
6643                                        {
6644                                        setState(856);
6645                                        match(WS);
6646                                        }
6647                                        break;
6648                                default:
6649                                        throw new NoViableAltException(this);
6650                                }
6651                                }
6652                                setState(861);
6653                                _errHandler.sync(this);
6654                                _la = _input.LA(1);
6655                        }
6656                        setState(862);
6657                        match(END);
6658                        }
6659                        _ctx.stop = _input.LT(-1);
6660
6661                            if (isNonTight && nonTightTagStartContext == null) {
6662                                nonTightTagStartContext = _localctx;
6663                            }
6664
6665                }
6666                catch (RecognitionException re) {
6667                        _localctx.exception = re;
6668                        _errHandler.reportError(this, re);
6669                        _errHandler.recover(this, re);
6670                }
6671                finally {
6672                        exitRule();
6673                }
6674                return _localctx;
6675        }
6676
6677        public static class DtTagEndContext extends ParserRuleContext {
6678                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
6679                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6680                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6681                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
6682                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6683                public TerminalNode NEWLINE(int i) {
6684                        return getToken(JavadocParser.NEWLINE, i);
6685                }
6686                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6687                public TerminalNode LEADING_ASTERISK(int i) {
6688                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6689                }
6690                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6691                public TerminalNode WS(int i) {
6692                        return getToken(JavadocParser.WS, i);
6693                }
6694                public DtTagEndContext(ParserRuleContext parent, int invokingState) {
6695                        super(parent, invokingState);
6696                }
6697                @Override public int getRuleIndex() { return RULE_dtTagEnd; }
6698        }
6699
6700        public final DtTagEndContext dtTagEnd() throws RecognitionException {
6701                DtTagEndContext _localctx = new DtTagEndContext(_ctx, getState());
6702                enterRule(_localctx, 62, RULE_dtTagEnd);
6703                int _la;
6704                try {
6705                        enterOuterAlt(_localctx, 1);
6706                        {
6707                        setState(864);
6708                        match(START);
6709                        setState(865);
6710                        match(SLASH);
6711                        setState(866);
6712                        match(DT_HTML_TAG_NAME);
6713                        setState(870);
6714                        _errHandler.sync(this);
6715                        _la = _input.LA(1);
6716                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6717                                {
6718                                {
6719                                setState(867);
6720                                _la = _input.LA(1);
6721                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6722                                _errHandler.recoverInline(this);
6723                                }
6724                                else {
6725                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
6726                                        _errHandler.reportMatch(this);
6727                                        consume();
6728                                }
6729                                }
6730                                }
6731                                setState(872);
6732                                _errHandler.sync(this);
6733                                _la = _input.LA(1);
6734                        }
6735                        setState(873);
6736                        match(END);
6737                        }
6738                }
6739                catch (RecognitionException re) {
6740                        _localctx.exception = re;
6741                        _errHandler.reportError(this, re);
6742                        _errHandler.recover(this, re);
6743                }
6744                finally {
6745                        exitRule();
6746                }
6747                return _localctx;
6748        }
6749
6750        public static class DtContext extends ParserRuleContext {
6751                public DtTagStartContext dtTagStart() {
6752                        return getRuleContext(DtTagStartContext.class,0);
6753                }
6754                public DtTagEndContext dtTagEnd() {
6755                        return getRuleContext(DtTagEndContext.class,0);
6756                }
6757                public List<HtmlTagContext> htmlTag() {
6758                        return getRuleContexts(HtmlTagContext.class);
6759                }
6760                public HtmlTagContext htmlTag(int i) {
6761                        return getRuleContext(HtmlTagContext.class,i);
6762                }
6763                public List<SingletonElementContext> singletonElement() {
6764                        return getRuleContexts(SingletonElementContext.class);
6765                }
6766                public SingletonElementContext singletonElement(int i) {
6767                        return getRuleContext(SingletonElementContext.class,i);
6768                }
6769                public List<ParagraphContext> paragraph() {
6770                        return getRuleContexts(ParagraphContext.class);
6771                }
6772                public ParagraphContext paragraph(int i) {
6773                        return getRuleContext(ParagraphContext.class,i);
6774                }
6775                public List<LiContext> li() {
6776                        return getRuleContexts(LiContext.class);
6777                }
6778                public LiContext li(int i) {
6779                        return getRuleContext(LiContext.class,i);
6780                }
6781                public List<TrContext> tr() {
6782                        return getRuleContexts(TrContext.class);
6783                }
6784                public TrContext tr(int i) {
6785                        return getRuleContext(TrContext.class,i);
6786                }
6787                public List<TdContext> td() {
6788                        return getRuleContexts(TdContext.class);
6789                }
6790                public TdContext td(int i) {
6791                        return getRuleContext(TdContext.class,i);
6792                }
6793                public List<ThContext> th() {
6794                        return getRuleContexts(ThContext.class);
6795                }
6796                public ThContext th(int i) {
6797                        return getRuleContext(ThContext.class,i);
6798                }
6799                public List<BodyContext> body() {
6800                        return getRuleContexts(BodyContext.class);
6801                }
6802                public BodyContext body(int i) {
6803                        return getRuleContext(BodyContext.class,i);
6804                }
6805                public List<ColgroupContext> colgroup() {
6806                        return getRuleContexts(ColgroupContext.class);
6807                }
6808                public ColgroupContext colgroup(int i) {
6809                        return getRuleContext(ColgroupContext.class,i);
6810                }
6811                public List<DdContext> dd() {
6812                        return getRuleContexts(DdContext.class);
6813                }
6814                public DdContext dd(int i) {
6815                        return getRuleContext(DdContext.class,i);
6816                }
6817                public List<HeadContext> head() {
6818                        return getRuleContexts(HeadContext.class);
6819                }
6820                public HeadContext head(int i) {
6821                        return getRuleContext(HeadContext.class,i);
6822                }
6823                public List<HtmlContext> html() {
6824                        return getRuleContexts(HtmlContext.class);
6825                }
6826                public HtmlContext html(int i) {
6827                        return getRuleContext(HtmlContext.class,i);
6828                }
6829                public List<OptionContext> option() {
6830                        return getRuleContexts(OptionContext.class);
6831                }
6832                public OptionContext option(int i) {
6833                        return getRuleContext(OptionContext.class,i);
6834                }
6835                public List<TbodyContext> tbody() {
6836                        return getRuleContexts(TbodyContext.class);
6837                }
6838                public TbodyContext tbody(int i) {
6839                        return getRuleContext(TbodyContext.class,i);
6840                }
6841                public List<TheadContext> thead() {
6842                        return getRuleContexts(TheadContext.class);
6843                }
6844                public TheadContext thead(int i) {
6845                        return getRuleContext(TheadContext.class,i);
6846                }
6847                public List<TfootContext> tfoot() {
6848                        return getRuleContexts(TfootContext.class);
6849                }
6850                public TfootContext tfoot(int i) {
6851                        return getRuleContext(TfootContext.class,i);
6852                }
6853                public List<PTagStartContext> pTagStart() {
6854                        return getRuleContexts(PTagStartContext.class);
6855                }
6856                public PTagStartContext pTagStart(int i) {
6857                        return getRuleContext(PTagStartContext.class,i);
6858                }
6859                public List<LiTagStartContext> liTagStart() {
6860                        return getRuleContexts(LiTagStartContext.class);
6861                }
6862                public LiTagStartContext liTagStart(int i) {
6863                        return getRuleContext(LiTagStartContext.class,i);
6864                }
6865                public List<TrTagStartContext> trTagStart() {
6866                        return getRuleContexts(TrTagStartContext.class);
6867                }
6868                public TrTagStartContext trTagStart(int i) {
6869                        return getRuleContext(TrTagStartContext.class,i);
6870                }
6871                public List<TdTagStartContext> tdTagStart() {
6872                        return getRuleContexts(TdTagStartContext.class);
6873                }
6874                public TdTagStartContext tdTagStart(int i) {
6875                        return getRuleContext(TdTagStartContext.class,i);
6876                }
6877                public List<ThTagStartContext> thTagStart() {
6878                        return getRuleContexts(ThTagStartContext.class);
6879                }
6880                public ThTagStartContext thTagStart(int i) {
6881                        return getRuleContext(ThTagStartContext.class,i);
6882                }
6883                public List<BodyTagStartContext> bodyTagStart() {
6884                        return getRuleContexts(BodyTagStartContext.class);
6885                }
6886                public BodyTagStartContext bodyTagStart(int i) {
6887                        return getRuleContext(BodyTagStartContext.class,i);
6888                }
6889                public List<ColgroupTagStartContext> colgroupTagStart() {
6890                        return getRuleContexts(ColgroupTagStartContext.class);
6891                }
6892                public ColgroupTagStartContext colgroupTagStart(int i) {
6893                        return getRuleContext(ColgroupTagStartContext.class,i);
6894                }
6895                public List<DdTagStartContext> ddTagStart() {
6896                        return getRuleContexts(DdTagStartContext.class);
6897                }
6898                public DdTagStartContext ddTagStart(int i) {
6899                        return getRuleContext(DdTagStartContext.class,i);
6900                }
6901                public List<HeadTagStartContext> headTagStart() {
6902                        return getRuleContexts(HeadTagStartContext.class);
6903                }
6904                public HeadTagStartContext headTagStart(int i) {
6905                        return getRuleContext(HeadTagStartContext.class,i);
6906                }
6907                public List<HtmlTagStartContext> htmlTagStart() {
6908                        return getRuleContexts(HtmlTagStartContext.class);
6909                }
6910                public HtmlTagStartContext htmlTagStart(int i) {
6911                        return getRuleContext(HtmlTagStartContext.class,i);
6912                }
6913                public List<OptionTagStartContext> optionTagStart() {
6914                        return getRuleContexts(OptionTagStartContext.class);
6915                }
6916                public OptionTagStartContext optionTagStart(int i) {
6917                        return getRuleContext(OptionTagStartContext.class,i);
6918                }
6919                public List<TbodyTagStartContext> tbodyTagStart() {
6920                        return getRuleContexts(TbodyTagStartContext.class);
6921                }
6922                public TbodyTagStartContext tbodyTagStart(int i) {
6923                        return getRuleContext(TbodyTagStartContext.class,i);
6924                }
6925                public List<TheadTagStartContext> theadTagStart() {
6926                        return getRuleContexts(TheadTagStartContext.class);
6927                }
6928                public TheadTagStartContext theadTagStart(int i) {
6929                        return getRuleContext(TheadTagStartContext.class,i);
6930                }
6931                public List<TfootTagStartContext> tfootTagStart() {
6932                        return getRuleContexts(TfootTagStartContext.class);
6933                }
6934                public TfootTagStartContext tfootTagStart(int i) {
6935                        return getRuleContext(TfootTagStartContext.class,i);
6936                }
6937                public List<HtmlCommentContext> htmlComment() {
6938                        return getRuleContexts(HtmlCommentContext.class);
6939                }
6940                public HtmlCommentContext htmlComment(int i) {
6941                        return getRuleContext(HtmlCommentContext.class,i);
6942                }
6943                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6944                public TerminalNode CDATA(int i) {
6945                        return getToken(JavadocParser.CDATA, i);
6946                }
6947                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6948                public TerminalNode NEWLINE(int i) {
6949                        return getToken(JavadocParser.NEWLINE, i);
6950                }
6951                public List<TextContext> text() {
6952                        return getRuleContexts(TextContext.class);
6953                }
6954                public TextContext text(int i) {
6955                        return getRuleContext(TextContext.class,i);
6956                }
6957                public List<JavadocInlineTagContext> javadocInlineTag() {
6958                        return getRuleContexts(JavadocInlineTagContext.class);
6959                }
6960                public JavadocInlineTagContext javadocInlineTag(int i) {
6961                        return getRuleContext(JavadocInlineTagContext.class,i);
6962                }
6963                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6964                public TerminalNode LEADING_ASTERISK(int i) {
6965                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6966                }
6967                public DtContext(ParserRuleContext parent, int invokingState) {
6968                        super(parent, invokingState);
6969                }
6970                @Override public int getRuleIndex() { return RULE_dt; }
6971        }
6972
6973        public final DtContext dt() throws RecognitionException {
6974                DtContext _localctx = new DtContext(_ctx, getState());
6975                enterRule(_localctx, 64, RULE_dt);
6976                try {
6977                        int _alt;
6978                        enterOuterAlt(_localctx, 1);
6979                        {
6980                        setState(875);
6981                        dtTagStart(false);
6982                        setState(915);
6983                        _errHandler.sync(this);
6984                        _alt = getInterpreter().adaptivePredict(_input,58,_ctx);
6985                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6986                                if ( _alt==1 ) {
6987                                        {
6988                                        setState(913);
6989                                        _errHandler.sync(this);
6990                                        switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
6991                                        case 1:
6992                                                {
6993                                                setState(876);
6994                                                htmlTag();
6995                                                }
6996                                                break;
6997                                        case 2:
6998                                                {
6999                                                setState(877);
7000                                                singletonElement();
7001                                                }
7002                                                break;
7003                                        case 3:
7004                                                {
7005                                                setState(878);
7006                                                paragraph();
7007                                                }
7008                                                break;
7009                                        case 4:
7010                                                {
7011                                                setState(879);
7012                                                li();
7013                                                }
7014                                                break;
7015                                        case 5:
7016                                                {
7017                                                setState(880);
7018                                                tr();
7019                                                }
7020                                                break;
7021                                        case 6:
7022                                                {
7023                                                setState(881);
7024                                                td();
7025                                                }
7026                                                break;
7027                                        case 7:
7028                                                {
7029                                                setState(882);
7030                                                th();
7031                                                }
7032                                                break;
7033                                        case 8:
7034                                                {
7035                                                setState(883);
7036                                                body();
7037                                                }
7038                                                break;
7039                                        case 9:
7040                                                {
7041                                                setState(884);
7042                                                colgroup();
7043                                                }
7044                                                break;
7045                                        case 10:
7046                                                {
7047                                                setState(885);
7048                                                dd();
7049                                                }
7050                                                break;
7051                                        case 11:
7052                                                {
7053                                                setState(886);
7054                                                head();
7055                                                }
7056                                                break;
7057                                        case 12:
7058                                                {
7059                                                setState(887);
7060                                                html();
7061                                                }
7062                                                break;
7063                                        case 13:
7064                                                {
7065                                                setState(888);
7066                                                option();
7067                                                }
7068                                                break;
7069                                        case 14:
7070                                                {
7071                                                setState(889);
7072                                                tbody();
7073                                                }
7074                                                break;
7075                                        case 15:
7076                                                {
7077                                                setState(890);
7078                                                thead();
7079                                                }
7080                                                break;
7081                                        case 16:
7082                                                {
7083                                                setState(891);
7084                                                tfoot();
7085                                                }
7086                                                break;
7087                                        case 17:
7088                                                {
7089                                                setState(892);
7090                                                pTagStart(true);
7091                                                }
7092                                                break;
7093                                        case 18:
7094                                                {
7095                                                setState(893);
7096                                                liTagStart(true);
7097                                                }
7098                                                break;
7099                                        case 19:
7100                                                {
7101                                                setState(894);
7102                                                trTagStart(true);
7103                                                }
7104                                                break;
7105                                        case 20:
7106                                                {
7107                                                setState(895);
7108                                                tdTagStart(true);
7109                                                }
7110                                                break;
7111                                        case 21:
7112                                                {
7113                                                setState(896);
7114                                                thTagStart(true);
7115                                                }
7116                                                break;
7117                                        case 22:
7118                                                {
7119                                                setState(897);
7120                                                bodyTagStart(true);
7121                                                }
7122                                                break;
7123                                        case 23:
7124                                                {
7125                                                setState(898);
7126                                                colgroupTagStart(true);
7127                                                }
7128                                                break;
7129                                        case 24:
7130                                                {
7131                                                setState(899);
7132                                                ddTagStart(true);
7133                                                }
7134                                                break;
7135                                        case 25:
7136                                                {
7137                                                setState(900);
7138                                                headTagStart(true);
7139                                                }
7140                                                break;
7141                                        case 26:
7142                                                {
7143                                                setState(901);
7144                                                htmlTagStart(true);
7145                                                }
7146                                                break;
7147                                        case 27:
7148                                                {
7149                                                setState(902);
7150                                                optionTagStart(true);
7151                                                }
7152                                                break;
7153                                        case 28:
7154                                                {
7155                                                setState(903);
7156                                                tbodyTagStart(true);
7157                                                }
7158                                                break;
7159                                        case 29:
7160                                                {
7161                                                setState(904);
7162                                                theadTagStart(true);
7163                                                }
7164                                                break;
7165                                        case 30:
7166                                                {
7167                                                setState(905);
7168                                                tfootTagStart(true);
7169                                                }
7170                                                break;
7171                                        case 31:
7172                                                {
7173                                                {
7174                                                setState(906);
7175                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7176                                                setState(907);
7177                                                match(LEADING_ASTERISK);
7178                                                }
7179                                                }
7180                                                break;
7181                                        case 32:
7182                                                {
7183                                                setState(908);
7184                                                htmlComment();
7185                                                }
7186                                                break;
7187                                        case 33:
7188                                                {
7189                                                setState(909);
7190                                                match(CDATA);
7191                                                }
7192                                                break;
7193                                        case 34:
7194                                                {
7195                                                setState(910);
7196                                                match(NEWLINE);
7197                                                }
7198                                                break;
7199                                        case 35:
7200                                                {
7201                                                setState(911);
7202                                                text();
7203                                                }
7204                                                break;
7205                                        case 36:
7206                                                {
7207                                                setState(912);
7208                                                javadocInlineTag();
7209                                                }
7210                                                break;
7211                                        }
7212                                        } 
7213                                }
7214                                setState(917);
7215                                _errHandler.sync(this);
7216                                _alt = getInterpreter().adaptivePredict(_input,58,_ctx);
7217                        }
7218                        setState(918);
7219                        dtTagEnd();
7220                        }
7221                }
7222                catch (RecognitionException re) {
7223                        _localctx.exception = re;
7224                        _errHandler.reportError(this, re);
7225                        _errHandler.recover(this, re);
7226                }
7227                finally {
7228                        exitRule();
7229                }
7230                return _localctx;
7231        }
7232
7233        public static class HeadTagStartContext extends ParserRuleContext {
7234                public boolean isNonTight;
7235                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7236                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7237                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
7238                public List<AttributeContext> attribute() {
7239                        return getRuleContexts(AttributeContext.class);
7240                }
7241                public AttributeContext attribute(int i) {
7242                        return getRuleContext(AttributeContext.class,i);
7243                }
7244                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7245                public TerminalNode NEWLINE(int i) {
7246                        return getToken(JavadocParser.NEWLINE, i);
7247                }
7248                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7249                public TerminalNode LEADING_ASTERISK(int i) {
7250                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7251                }
7252                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7253                public TerminalNode WS(int i) {
7254                        return getToken(JavadocParser.WS, i);
7255                }
7256                public HeadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
7257                public HeadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
7258                        super(parent, invokingState);
7259                        this.isNonTight = isNonTight;
7260                }
7261                @Override public int getRuleIndex() { return RULE_headTagStart; }
7262        }
7263
7264        public final HeadTagStartContext headTagStart(boolean isNonTight) throws RecognitionException {
7265                HeadTagStartContext _localctx = new HeadTagStartContext(_ctx, getState(), isNonTight);
7266                enterRule(_localctx, 66, RULE_headTagStart);
7267                int _la;
7268                try {
7269                        enterOuterAlt(_localctx, 1);
7270                        {
7271                        setState(920);
7272                        match(START);
7273                        setState(921);
7274                        match(HEAD_HTML_TAG_NAME);
7275                        setState(928);
7276                        _errHandler.sync(this);
7277                        _la = _input.LA(1);
7278                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7279                                {
7280                                setState(926);
7281                                _errHandler.sync(this);
7282                                switch (_input.LA(1)) {
7283                                case HTML_TAG_NAME:
7284                                        {
7285                                        setState(922);
7286                                        attribute();
7287                                        }
7288                                        break;
7289                                case NEWLINE:
7290                                        {
7291                                        setState(923);
7292                                        match(NEWLINE);
7293                                        }
7294                                        break;
7295                                case LEADING_ASTERISK:
7296                                        {
7297                                        setState(924);
7298                                        match(LEADING_ASTERISK);
7299                                        }
7300                                        break;
7301                                case WS:
7302                                        {
7303                                        setState(925);
7304                                        match(WS);
7305                                        }
7306                                        break;
7307                                default:
7308                                        throw new NoViableAltException(this);
7309                                }
7310                                }
7311                                setState(930);
7312                                _errHandler.sync(this);
7313                                _la = _input.LA(1);
7314                        }
7315                        setState(931);
7316                        match(END);
7317                        }
7318                        _ctx.stop = _input.LT(-1);
7319
7320                            if (isNonTight && nonTightTagStartContext == null) {
7321                                nonTightTagStartContext = _localctx;
7322                            }
7323
7324                }
7325                catch (RecognitionException re) {
7326                        _localctx.exception = re;
7327                        _errHandler.reportError(this, re);
7328                        _errHandler.recover(this, re);
7329                }
7330                finally {
7331                        exitRule();
7332                }
7333                return _localctx;
7334        }
7335
7336        public static class HeadTagEndContext extends ParserRuleContext {
7337                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7338                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7339                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7340                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
7341                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7342                public TerminalNode NEWLINE(int i) {
7343                        return getToken(JavadocParser.NEWLINE, i);
7344                }
7345                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7346                public TerminalNode LEADING_ASTERISK(int i) {
7347                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7348                }
7349                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7350                public TerminalNode WS(int i) {
7351                        return getToken(JavadocParser.WS, i);
7352                }
7353                public HeadTagEndContext(ParserRuleContext parent, int invokingState) {
7354                        super(parent, invokingState);
7355                }
7356                @Override public int getRuleIndex() { return RULE_headTagEnd; }
7357        }
7358
7359        public final HeadTagEndContext headTagEnd() throws RecognitionException {
7360                HeadTagEndContext _localctx = new HeadTagEndContext(_ctx, getState());
7361                enterRule(_localctx, 68, RULE_headTagEnd);
7362                int _la;
7363                try {
7364                        enterOuterAlt(_localctx, 1);
7365                        {
7366                        setState(933);
7367                        match(START);
7368                        setState(934);
7369                        match(SLASH);
7370                        setState(935);
7371                        match(HEAD_HTML_TAG_NAME);
7372                        setState(939);
7373                        _errHandler.sync(this);
7374                        _la = _input.LA(1);
7375                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7376                                {
7377                                {
7378                                setState(936);
7379                                _la = _input.LA(1);
7380                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7381                                _errHandler.recoverInline(this);
7382                                }
7383                                else {
7384                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
7385                                        _errHandler.reportMatch(this);
7386                                        consume();
7387                                }
7388                                }
7389                                }
7390                                setState(941);
7391                                _errHandler.sync(this);
7392                                _la = _input.LA(1);
7393                        }
7394                        setState(942);
7395                        match(END);
7396                        }
7397                }
7398                catch (RecognitionException re) {
7399                        _localctx.exception = re;
7400                        _errHandler.reportError(this, re);
7401                        _errHandler.recover(this, re);
7402                }
7403                finally {
7404                        exitRule();
7405                }
7406                return _localctx;
7407        }
7408
7409        public static class HeadContext extends ParserRuleContext {
7410                public HeadTagStartContext headTagStart() {
7411                        return getRuleContext(HeadTagStartContext.class,0);
7412                }
7413                public HeadTagEndContext headTagEnd() {
7414                        return getRuleContext(HeadTagEndContext.class,0);
7415                }
7416                public List<HtmlTagContext> htmlTag() {
7417                        return getRuleContexts(HtmlTagContext.class);
7418                }
7419                public HtmlTagContext htmlTag(int i) {
7420                        return getRuleContext(HtmlTagContext.class,i);
7421                }
7422                public List<SingletonElementContext> singletonElement() {
7423                        return getRuleContexts(SingletonElementContext.class);
7424                }
7425                public SingletonElementContext singletonElement(int i) {
7426                        return getRuleContext(SingletonElementContext.class,i);
7427                }
7428                public List<ParagraphContext> paragraph() {
7429                        return getRuleContexts(ParagraphContext.class);
7430                }
7431                public ParagraphContext paragraph(int i) {
7432                        return getRuleContext(ParagraphContext.class,i);
7433                }
7434                public List<LiContext> li() {
7435                        return getRuleContexts(LiContext.class);
7436                }
7437                public LiContext li(int i) {
7438                        return getRuleContext(LiContext.class,i);
7439                }
7440                public List<TrContext> tr() {
7441                        return getRuleContexts(TrContext.class);
7442                }
7443                public TrContext tr(int i) {
7444                        return getRuleContext(TrContext.class,i);
7445                }
7446                public List<TdContext> td() {
7447                        return getRuleContexts(TdContext.class);
7448                }
7449                public TdContext td(int i) {
7450                        return getRuleContext(TdContext.class,i);
7451                }
7452                public List<ThContext> th() {
7453                        return getRuleContexts(ThContext.class);
7454                }
7455                public ThContext th(int i) {
7456                        return getRuleContext(ThContext.class,i);
7457                }
7458                public List<BodyContext> body() {
7459                        return getRuleContexts(BodyContext.class);
7460                }
7461                public BodyContext body(int i) {
7462                        return getRuleContext(BodyContext.class,i);
7463                }
7464                public List<ColgroupContext> colgroup() {
7465                        return getRuleContexts(ColgroupContext.class);
7466                }
7467                public ColgroupContext colgroup(int i) {
7468                        return getRuleContext(ColgroupContext.class,i);
7469                }
7470                public List<DdContext> dd() {
7471                        return getRuleContexts(DdContext.class);
7472                }
7473                public DdContext dd(int i) {
7474                        return getRuleContext(DdContext.class,i);
7475                }
7476                public List<DtContext> dt() {
7477                        return getRuleContexts(DtContext.class);
7478                }
7479                public DtContext dt(int i) {
7480                        return getRuleContext(DtContext.class,i);
7481                }
7482                public List<HtmlContext> html() {
7483                        return getRuleContexts(HtmlContext.class);
7484                }
7485                public HtmlContext html(int i) {
7486                        return getRuleContext(HtmlContext.class,i);
7487                }
7488                public List<OptionContext> option() {
7489                        return getRuleContexts(OptionContext.class);
7490                }
7491                public OptionContext option(int i) {
7492                        return getRuleContext(OptionContext.class,i);
7493                }
7494                public List<TbodyContext> tbody() {
7495                        return getRuleContexts(TbodyContext.class);
7496                }
7497                public TbodyContext tbody(int i) {
7498                        return getRuleContext(TbodyContext.class,i);
7499                }
7500                public List<TheadContext> thead() {
7501                        return getRuleContexts(TheadContext.class);
7502                }
7503                public TheadContext thead(int i) {
7504                        return getRuleContext(TheadContext.class,i);
7505                }
7506                public List<TfootContext> tfoot() {
7507                        return getRuleContexts(TfootContext.class);
7508                }
7509                public TfootContext tfoot(int i) {
7510                        return getRuleContext(TfootContext.class,i);
7511                }
7512                public List<PTagStartContext> pTagStart() {
7513                        return getRuleContexts(PTagStartContext.class);
7514                }
7515                public PTagStartContext pTagStart(int i) {
7516                        return getRuleContext(PTagStartContext.class,i);
7517                }
7518                public List<LiTagStartContext> liTagStart() {
7519                        return getRuleContexts(LiTagStartContext.class);
7520                }
7521                public LiTagStartContext liTagStart(int i) {
7522                        return getRuleContext(LiTagStartContext.class,i);
7523                }
7524                public List<TrTagStartContext> trTagStart() {
7525                        return getRuleContexts(TrTagStartContext.class);
7526                }
7527                public TrTagStartContext trTagStart(int i) {
7528                        return getRuleContext(TrTagStartContext.class,i);
7529                }
7530                public List<TdTagStartContext> tdTagStart() {
7531                        return getRuleContexts(TdTagStartContext.class);
7532                }
7533                public TdTagStartContext tdTagStart(int i) {
7534                        return getRuleContext(TdTagStartContext.class,i);
7535                }
7536                public List<ThTagStartContext> thTagStart() {
7537                        return getRuleContexts(ThTagStartContext.class);
7538                }
7539                public ThTagStartContext thTagStart(int i) {
7540                        return getRuleContext(ThTagStartContext.class,i);
7541                }
7542                public List<BodyTagStartContext> bodyTagStart() {
7543                        return getRuleContexts(BodyTagStartContext.class);
7544                }
7545                public BodyTagStartContext bodyTagStart(int i) {
7546                        return getRuleContext(BodyTagStartContext.class,i);
7547                }
7548                public List<ColgroupTagStartContext> colgroupTagStart() {
7549                        return getRuleContexts(ColgroupTagStartContext.class);
7550                }
7551                public ColgroupTagStartContext colgroupTagStart(int i) {
7552                        return getRuleContext(ColgroupTagStartContext.class,i);
7553                }
7554                public List<DdTagStartContext> ddTagStart() {
7555                        return getRuleContexts(DdTagStartContext.class);
7556                }
7557                public DdTagStartContext ddTagStart(int i) {
7558                        return getRuleContext(DdTagStartContext.class,i);
7559                }
7560                public List<DtTagStartContext> dtTagStart() {
7561                        return getRuleContexts(DtTagStartContext.class);
7562                }
7563                public DtTagStartContext dtTagStart(int i) {
7564                        return getRuleContext(DtTagStartContext.class,i);
7565                }
7566                public List<HtmlTagStartContext> htmlTagStart() {
7567                        return getRuleContexts(HtmlTagStartContext.class);
7568                }
7569                public HtmlTagStartContext htmlTagStart(int i) {
7570                        return getRuleContext(HtmlTagStartContext.class,i);
7571                }
7572                public List<OptionTagStartContext> optionTagStart() {
7573                        return getRuleContexts(OptionTagStartContext.class);
7574                }
7575                public OptionTagStartContext optionTagStart(int i) {
7576                        return getRuleContext(OptionTagStartContext.class,i);
7577                }
7578                public List<TbodyTagStartContext> tbodyTagStart() {
7579                        return getRuleContexts(TbodyTagStartContext.class);
7580                }
7581                public TbodyTagStartContext tbodyTagStart(int i) {
7582                        return getRuleContext(TbodyTagStartContext.class,i);
7583                }
7584                public List<TheadTagStartContext> theadTagStart() {
7585                        return getRuleContexts(TheadTagStartContext.class);
7586                }
7587                public TheadTagStartContext theadTagStart(int i) {
7588                        return getRuleContext(TheadTagStartContext.class,i);
7589                }
7590                public List<TfootTagStartContext> tfootTagStart() {
7591                        return getRuleContexts(TfootTagStartContext.class);
7592                }
7593                public TfootTagStartContext tfootTagStart(int i) {
7594                        return getRuleContext(TfootTagStartContext.class,i);
7595                }
7596                public List<HtmlCommentContext> htmlComment() {
7597                        return getRuleContexts(HtmlCommentContext.class);
7598                }
7599                public HtmlCommentContext htmlComment(int i) {
7600                        return getRuleContext(HtmlCommentContext.class,i);
7601                }
7602                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7603                public TerminalNode CDATA(int i) {
7604                        return getToken(JavadocParser.CDATA, i);
7605                }
7606                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7607                public TerminalNode NEWLINE(int i) {
7608                        return getToken(JavadocParser.NEWLINE, i);
7609                }
7610                public List<TextContext> text() {
7611                        return getRuleContexts(TextContext.class);
7612                }
7613                public TextContext text(int i) {
7614                        return getRuleContext(TextContext.class,i);
7615                }
7616                public List<JavadocInlineTagContext> javadocInlineTag() {
7617                        return getRuleContexts(JavadocInlineTagContext.class);
7618                }
7619                public JavadocInlineTagContext javadocInlineTag(int i) {
7620                        return getRuleContext(JavadocInlineTagContext.class,i);
7621                }
7622                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7623                public TerminalNode LEADING_ASTERISK(int i) {
7624                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7625                }
7626                public HeadContext(ParserRuleContext parent, int invokingState) {
7627                        super(parent, invokingState);
7628                }
7629                @Override public int getRuleIndex() { return RULE_head; }
7630        }
7631
7632        public final HeadContext head() throws RecognitionException {
7633                HeadContext _localctx = new HeadContext(_ctx, getState());
7634                enterRule(_localctx, 70, RULE_head);
7635                try {
7636                        int _alt;
7637                        enterOuterAlt(_localctx, 1);
7638                        {
7639                        setState(944);
7640                        headTagStart(false);
7641                        setState(984);
7642                        _errHandler.sync(this);
7643                        _alt = getInterpreter().adaptivePredict(_input,63,_ctx);
7644                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7645                                if ( _alt==1 ) {
7646                                        {
7647                                        setState(982);
7648                                        _errHandler.sync(this);
7649                                        switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
7650                                        case 1:
7651                                                {
7652                                                setState(945);
7653                                                htmlTag();
7654                                                }
7655                                                break;
7656                                        case 2:
7657                                                {
7658                                                setState(946);
7659                                                singletonElement();
7660                                                }
7661                                                break;
7662                                        case 3:
7663                                                {
7664                                                setState(947);
7665                                                paragraph();
7666                                                }
7667                                                break;
7668                                        case 4:
7669                                                {
7670                                                setState(948);
7671                                                li();
7672                                                }
7673                                                break;
7674                                        case 5:
7675                                                {
7676                                                setState(949);
7677                                                tr();
7678                                                }
7679                                                break;
7680                                        case 6:
7681                                                {
7682                                                setState(950);
7683                                                td();
7684                                                }
7685                                                break;
7686                                        case 7:
7687                                                {
7688                                                setState(951);
7689                                                th();
7690                                                }
7691                                                break;
7692                                        case 8:
7693                                                {
7694                                                setState(952);
7695                                                body();
7696                                                }
7697                                                break;
7698                                        case 9:
7699                                                {
7700                                                setState(953);
7701                                                colgroup();
7702                                                }
7703                                                break;
7704                                        case 10:
7705                                                {
7706                                                setState(954);
7707                                                dd();
7708                                                }
7709                                                break;
7710                                        case 11:
7711                                                {
7712                                                setState(955);
7713                                                dt();
7714                                                }
7715                                                break;
7716                                        case 12:
7717                                                {
7718                                                setState(956);
7719                                                html();
7720                                                }
7721                                                break;
7722                                        case 13:
7723                                                {
7724                                                setState(957);
7725                                                option();
7726                                                }
7727                                                break;
7728                                        case 14:
7729                                                {
7730                                                setState(958);
7731                                                tbody();
7732                                                }
7733                                                break;
7734                                        case 15:
7735                                                {
7736                                                setState(959);
7737                                                thead();
7738                                                }
7739                                                break;
7740                                        case 16:
7741                                                {
7742                                                setState(960);
7743                                                tfoot();
7744                                                }
7745                                                break;
7746                                        case 17:
7747                                                {
7748                                                setState(961);
7749                                                pTagStart(true);
7750                                                }
7751                                                break;
7752                                        case 18:
7753                                                {
7754                                                setState(962);
7755                                                liTagStart(true);
7756                                                }
7757                                                break;
7758                                        case 19:
7759                                                {
7760                                                setState(963);
7761                                                trTagStart(true);
7762                                                }
7763                                                break;
7764                                        case 20:
7765                                                {
7766                                                setState(964);
7767                                                tdTagStart(true);
7768                                                }
7769                                                break;
7770                                        case 21:
7771                                                {
7772                                                setState(965);
7773                                                thTagStart(true);
7774                                                }
7775                                                break;
7776                                        case 22:
7777                                                {
7778                                                setState(966);
7779                                                bodyTagStart(true);
7780                                                }
7781                                                break;
7782                                        case 23:
7783                                                {
7784                                                setState(967);
7785                                                colgroupTagStart(true);
7786                                                }
7787                                                break;
7788                                        case 24:
7789                                                {
7790                                                setState(968);
7791                                                ddTagStart(true);
7792                                                }
7793                                                break;
7794                                        case 25:
7795                                                {
7796                                                setState(969);
7797                                                dtTagStart(true);
7798                                                }
7799                                                break;
7800                                        case 26:
7801                                                {
7802                                                setState(970);
7803                                                htmlTagStart(true);
7804                                                }
7805                                                break;
7806                                        case 27:
7807                                                {
7808                                                setState(971);
7809                                                optionTagStart(true);
7810                                                }
7811                                                break;
7812                                        case 28:
7813                                                {
7814                                                setState(972);
7815                                                tbodyTagStart(true);
7816                                                }
7817                                                break;
7818                                        case 29:
7819                                                {
7820                                                setState(973);
7821                                                theadTagStart(true);
7822                                                }
7823                                                break;
7824                                        case 30:
7825                                                {
7826                                                setState(974);
7827                                                tfootTagStart(true);
7828                                                }
7829                                                break;
7830                                        case 31:
7831                                                {
7832                                                {
7833                                                setState(975);
7834                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7835                                                setState(976);
7836                                                match(LEADING_ASTERISK);
7837                                                }
7838                                                }
7839                                                break;
7840                                        case 32:
7841                                                {
7842                                                setState(977);
7843                                                htmlComment();
7844                                                }
7845                                                break;
7846                                        case 33:
7847                                                {
7848                                                setState(978);
7849                                                match(CDATA);
7850                                                }
7851                                                break;
7852                                        case 34:
7853                                                {
7854                                                setState(979);
7855                                                match(NEWLINE);
7856                                                }
7857                                                break;
7858                                        case 35:
7859                                                {
7860                                                setState(980);
7861                                                text();
7862                                                }
7863                                                break;
7864                                        case 36:
7865                                                {
7866                                                setState(981);
7867                                                javadocInlineTag();
7868                                                }
7869                                                break;
7870                                        }
7871                                        } 
7872                                }
7873                                setState(986);
7874                                _errHandler.sync(this);
7875                                _alt = getInterpreter().adaptivePredict(_input,63,_ctx);
7876                        }
7877                        setState(987);
7878                        headTagEnd();
7879                        }
7880                }
7881                catch (RecognitionException re) {
7882                        _localctx.exception = re;
7883                        _errHandler.reportError(this, re);
7884                        _errHandler.recover(this, re);
7885                }
7886                finally {
7887                        exitRule();
7888                }
7889                return _localctx;
7890        }
7891
7892        public static class HtmlTagStartContext extends ParserRuleContext {
7893                public boolean isNonTight;
7894                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7895                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
7896                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
7897                public List<AttributeContext> attribute() {
7898                        return getRuleContexts(AttributeContext.class);
7899                }
7900                public AttributeContext attribute(int i) {
7901                        return getRuleContext(AttributeContext.class,i);
7902                }
7903                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7904                public TerminalNode NEWLINE(int i) {
7905                        return getToken(JavadocParser.NEWLINE, i);
7906                }
7907                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7908                public TerminalNode LEADING_ASTERISK(int i) {
7909                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7910                }
7911                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7912                public TerminalNode WS(int i) {
7913                        return getToken(JavadocParser.WS, i);
7914                }
7915                public HtmlTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
7916                public HtmlTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
7917                        super(parent, invokingState);
7918                        this.isNonTight = isNonTight;
7919                }
7920                @Override public int getRuleIndex() { return RULE_htmlTagStart; }
7921        }
7922
7923        public final HtmlTagStartContext htmlTagStart(boolean isNonTight) throws RecognitionException {
7924                HtmlTagStartContext _localctx = new HtmlTagStartContext(_ctx, getState(), isNonTight);
7925                enterRule(_localctx, 72, RULE_htmlTagStart);
7926                int _la;
7927                try {
7928                        enterOuterAlt(_localctx, 1);
7929                        {
7930                        setState(989);
7931                        match(START);
7932                        setState(990);
7933                        match(HTML_HTML_TAG_NAME);
7934                        setState(997);
7935                        _errHandler.sync(this);
7936                        _la = _input.LA(1);
7937                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7938                                {
7939                                setState(995);
7940                                _errHandler.sync(this);
7941                                switch (_input.LA(1)) {
7942                                case HTML_TAG_NAME:
7943                                        {
7944                                        setState(991);
7945                                        attribute();
7946                                        }
7947                                        break;
7948                                case NEWLINE:
7949                                        {
7950                                        setState(992);
7951                                        match(NEWLINE);
7952                                        }
7953                                        break;
7954                                case LEADING_ASTERISK:
7955                                        {
7956                                        setState(993);
7957                                        match(LEADING_ASTERISK);
7958                                        }
7959                                        break;
7960                                case WS:
7961                                        {
7962                                        setState(994);
7963                                        match(WS);
7964                                        }
7965                                        break;
7966                                default:
7967                                        throw new NoViableAltException(this);
7968                                }
7969                                }
7970                                setState(999);
7971                                _errHandler.sync(this);
7972                                _la = _input.LA(1);
7973                        }
7974                        setState(1000);
7975                        match(END);
7976                        }
7977                        _ctx.stop = _input.LT(-1);
7978
7979                            if (isNonTight && nonTightTagStartContext == null) {
7980                                nonTightTagStartContext = _localctx;
7981                            }
7982
7983                }
7984                catch (RecognitionException re) {
7985                        _localctx.exception = re;
7986                        _errHandler.reportError(this, re);
7987                        _errHandler.recover(this, re);
7988                }
7989                finally {
7990                        exitRule();
7991                }
7992                return _localctx;
7993        }
7994
7995        public static class HtmlTagEndContext extends ParserRuleContext {
7996                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
7997                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7998                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
7999                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
8000                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8001                public TerminalNode NEWLINE(int i) {
8002                        return getToken(JavadocParser.NEWLINE, i);
8003                }
8004                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8005                public TerminalNode LEADING_ASTERISK(int i) {
8006                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8007                }
8008                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8009                public TerminalNode WS(int i) {
8010                        return getToken(JavadocParser.WS, i);
8011                }
8012                public HtmlTagEndContext(ParserRuleContext parent, int invokingState) {
8013                        super(parent, invokingState);
8014                }
8015                @Override public int getRuleIndex() { return RULE_htmlTagEnd; }
8016        }
8017
8018        public final HtmlTagEndContext htmlTagEnd() throws RecognitionException {
8019                HtmlTagEndContext _localctx = new HtmlTagEndContext(_ctx, getState());
8020                enterRule(_localctx, 74, RULE_htmlTagEnd);
8021                int _la;
8022                try {
8023                        enterOuterAlt(_localctx, 1);
8024                        {
8025                        setState(1002);
8026                        match(START);
8027                        setState(1003);
8028                        match(SLASH);
8029                        setState(1004);
8030                        match(HTML_HTML_TAG_NAME);
8031                        setState(1008);
8032                        _errHandler.sync(this);
8033                        _la = _input.LA(1);
8034                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8035                                {
8036                                {
8037                                setState(1005);
8038                                _la = _input.LA(1);
8039                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8040                                _errHandler.recoverInline(this);
8041                                }
8042                                else {
8043                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
8044                                        _errHandler.reportMatch(this);
8045                                        consume();
8046                                }
8047                                }
8048                                }
8049                                setState(1010);
8050                                _errHandler.sync(this);
8051                                _la = _input.LA(1);
8052                        }
8053                        setState(1011);
8054                        match(END);
8055                        }
8056                }
8057                catch (RecognitionException re) {
8058                        _localctx.exception = re;
8059                        _errHandler.reportError(this, re);
8060                        _errHandler.recover(this, re);
8061                }
8062                finally {
8063                        exitRule();
8064                }
8065                return _localctx;
8066        }
8067
8068        public static class HtmlContext extends ParserRuleContext {
8069                public HtmlTagStartContext htmlTagStart() {
8070                        return getRuleContext(HtmlTagStartContext.class,0);
8071                }
8072                public HtmlTagEndContext htmlTagEnd() {
8073                        return getRuleContext(HtmlTagEndContext.class,0);
8074                }
8075                public List<HtmlTagContext> htmlTag() {
8076                        return getRuleContexts(HtmlTagContext.class);
8077                }
8078                public HtmlTagContext htmlTag(int i) {
8079                        return getRuleContext(HtmlTagContext.class,i);
8080                }
8081                public List<SingletonElementContext> singletonElement() {
8082                        return getRuleContexts(SingletonElementContext.class);
8083                }
8084                public SingletonElementContext singletonElement(int i) {
8085                        return getRuleContext(SingletonElementContext.class,i);
8086                }
8087                public List<ParagraphContext> paragraph() {
8088                        return getRuleContexts(ParagraphContext.class);
8089                }
8090                public ParagraphContext paragraph(int i) {
8091                        return getRuleContext(ParagraphContext.class,i);
8092                }
8093                public List<LiContext> li() {
8094                        return getRuleContexts(LiContext.class);
8095                }
8096                public LiContext li(int i) {
8097                        return getRuleContext(LiContext.class,i);
8098                }
8099                public List<TrContext> tr() {
8100                        return getRuleContexts(TrContext.class);
8101                }
8102                public TrContext tr(int i) {
8103                        return getRuleContext(TrContext.class,i);
8104                }
8105                public List<TdContext> td() {
8106                        return getRuleContexts(TdContext.class);
8107                }
8108                public TdContext td(int i) {
8109                        return getRuleContext(TdContext.class,i);
8110                }
8111                public List<ThContext> th() {
8112                        return getRuleContexts(ThContext.class);
8113                }
8114                public ThContext th(int i) {
8115                        return getRuleContext(ThContext.class,i);
8116                }
8117                public List<BodyContext> body() {
8118                        return getRuleContexts(BodyContext.class);
8119                }
8120                public BodyContext body(int i) {
8121                        return getRuleContext(BodyContext.class,i);
8122                }
8123                public List<ColgroupContext> colgroup() {
8124                        return getRuleContexts(ColgroupContext.class);
8125                }
8126                public ColgroupContext colgroup(int i) {
8127                        return getRuleContext(ColgroupContext.class,i);
8128                }
8129                public List<DdContext> dd() {
8130                        return getRuleContexts(DdContext.class);
8131                }
8132                public DdContext dd(int i) {
8133                        return getRuleContext(DdContext.class,i);
8134                }
8135                public List<DtContext> dt() {
8136                        return getRuleContexts(DtContext.class);
8137                }
8138                public DtContext dt(int i) {
8139                        return getRuleContext(DtContext.class,i);
8140                }
8141                public List<HeadContext> head() {
8142                        return getRuleContexts(HeadContext.class);
8143                }
8144                public HeadContext head(int i) {
8145                        return getRuleContext(HeadContext.class,i);
8146                }
8147                public List<OptionContext> option() {
8148                        return getRuleContexts(OptionContext.class);
8149                }
8150                public OptionContext option(int i) {
8151                        return getRuleContext(OptionContext.class,i);
8152                }
8153                public List<TbodyContext> tbody() {
8154                        return getRuleContexts(TbodyContext.class);
8155                }
8156                public TbodyContext tbody(int i) {
8157                        return getRuleContext(TbodyContext.class,i);
8158                }
8159                public List<TheadContext> thead() {
8160                        return getRuleContexts(TheadContext.class);
8161                }
8162                public TheadContext thead(int i) {
8163                        return getRuleContext(TheadContext.class,i);
8164                }
8165                public List<TfootContext> tfoot() {
8166                        return getRuleContexts(TfootContext.class);
8167                }
8168                public TfootContext tfoot(int i) {
8169                        return getRuleContext(TfootContext.class,i);
8170                }
8171                public List<PTagStartContext> pTagStart() {
8172                        return getRuleContexts(PTagStartContext.class);
8173                }
8174                public PTagStartContext pTagStart(int i) {
8175                        return getRuleContext(PTagStartContext.class,i);
8176                }
8177                public List<LiTagStartContext> liTagStart() {
8178                        return getRuleContexts(LiTagStartContext.class);
8179                }
8180                public LiTagStartContext liTagStart(int i) {
8181                        return getRuleContext(LiTagStartContext.class,i);
8182                }
8183                public List<TrTagStartContext> trTagStart() {
8184                        return getRuleContexts(TrTagStartContext.class);
8185                }
8186                public TrTagStartContext trTagStart(int i) {
8187                        return getRuleContext(TrTagStartContext.class,i);
8188                }
8189                public List<TdTagStartContext> tdTagStart() {
8190                        return getRuleContexts(TdTagStartContext.class);
8191                }
8192                public TdTagStartContext tdTagStart(int i) {
8193                        return getRuleContext(TdTagStartContext.class,i);
8194                }
8195                public List<ThTagStartContext> thTagStart() {
8196                        return getRuleContexts(ThTagStartContext.class);
8197                }
8198                public ThTagStartContext thTagStart(int i) {
8199                        return getRuleContext(ThTagStartContext.class,i);
8200                }
8201                public List<BodyTagStartContext> bodyTagStart() {
8202                        return getRuleContexts(BodyTagStartContext.class);
8203                }
8204                public BodyTagStartContext bodyTagStart(int i) {
8205                        return getRuleContext(BodyTagStartContext.class,i);
8206                }
8207                public List<ColgroupTagStartContext> colgroupTagStart() {
8208                        return getRuleContexts(ColgroupTagStartContext.class);
8209                }
8210                public ColgroupTagStartContext colgroupTagStart(int i) {
8211                        return getRuleContext(ColgroupTagStartContext.class,i);
8212                }
8213                public List<DdTagStartContext> ddTagStart() {
8214                        return getRuleContexts(DdTagStartContext.class);
8215                }
8216                public DdTagStartContext ddTagStart(int i) {
8217                        return getRuleContext(DdTagStartContext.class,i);
8218                }
8219                public List<DtTagStartContext> dtTagStart() {
8220                        return getRuleContexts(DtTagStartContext.class);
8221                }
8222                public DtTagStartContext dtTagStart(int i) {
8223                        return getRuleContext(DtTagStartContext.class,i);
8224                }
8225                public List<HeadTagStartContext> headTagStart() {
8226                        return getRuleContexts(HeadTagStartContext.class);
8227                }
8228                public HeadTagStartContext headTagStart(int i) {
8229                        return getRuleContext(HeadTagStartContext.class,i);
8230                }
8231                public List<OptionTagStartContext> optionTagStart() {
8232                        return getRuleContexts(OptionTagStartContext.class);
8233                }
8234                public OptionTagStartContext optionTagStart(int i) {
8235                        return getRuleContext(OptionTagStartContext.class,i);
8236                }
8237                public List<TbodyTagStartContext> tbodyTagStart() {
8238                        return getRuleContexts(TbodyTagStartContext.class);
8239                }
8240                public TbodyTagStartContext tbodyTagStart(int i) {
8241                        return getRuleContext(TbodyTagStartContext.class,i);
8242                }
8243                public List<TheadTagStartContext> theadTagStart() {
8244                        return getRuleContexts(TheadTagStartContext.class);
8245                }
8246                public TheadTagStartContext theadTagStart(int i) {
8247                        return getRuleContext(TheadTagStartContext.class,i);
8248                }
8249                public List<TfootTagStartContext> tfootTagStart() {
8250                        return getRuleContexts(TfootTagStartContext.class);
8251                }
8252                public TfootTagStartContext tfootTagStart(int i) {
8253                        return getRuleContext(TfootTagStartContext.class,i);
8254                }
8255                public List<HtmlCommentContext> htmlComment() {
8256                        return getRuleContexts(HtmlCommentContext.class);
8257                }
8258                public HtmlCommentContext htmlComment(int i) {
8259                        return getRuleContext(HtmlCommentContext.class,i);
8260                }
8261                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8262                public TerminalNode CDATA(int i) {
8263                        return getToken(JavadocParser.CDATA, i);
8264                }
8265                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8266                public TerminalNode NEWLINE(int i) {
8267                        return getToken(JavadocParser.NEWLINE, i);
8268                }
8269                public List<TextContext> text() {
8270                        return getRuleContexts(TextContext.class);
8271                }
8272                public TextContext text(int i) {
8273                        return getRuleContext(TextContext.class,i);
8274                }
8275                public List<JavadocInlineTagContext> javadocInlineTag() {
8276                        return getRuleContexts(JavadocInlineTagContext.class);
8277                }
8278                public JavadocInlineTagContext javadocInlineTag(int i) {
8279                        return getRuleContext(JavadocInlineTagContext.class,i);
8280                }
8281                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8282                public TerminalNode LEADING_ASTERISK(int i) {
8283                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8284                }
8285                public HtmlContext(ParserRuleContext parent, int invokingState) {
8286                        super(parent, invokingState);
8287                }
8288                @Override public int getRuleIndex() { return RULE_html; }
8289        }
8290
8291        public final HtmlContext html() throws RecognitionException {
8292                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8293                enterRule(_localctx, 76, RULE_html);
8294                try {
8295                        int _alt;
8296                        enterOuterAlt(_localctx, 1);
8297                        {
8298                        setState(1013);
8299                        htmlTagStart(false);
8300                        setState(1053);
8301                        _errHandler.sync(this);
8302                        _alt = getInterpreter().adaptivePredict(_input,68,_ctx);
8303                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8304                                if ( _alt==1 ) {
8305                                        {
8306                                        setState(1051);
8307                                        _errHandler.sync(this);
8308                                        switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
8309                                        case 1:
8310                                                {
8311                                                setState(1014);
8312                                                htmlTag();
8313                                                }
8314                                                break;
8315                                        case 2:
8316                                                {
8317                                                setState(1015);
8318                                                singletonElement();
8319                                                }
8320                                                break;
8321                                        case 3:
8322                                                {
8323                                                setState(1016);
8324                                                paragraph();
8325                                                }
8326                                                break;
8327                                        case 4:
8328                                                {
8329                                                setState(1017);
8330                                                li();
8331                                                }
8332                                                break;
8333                                        case 5:
8334                                                {
8335                                                setState(1018);
8336                                                tr();
8337                                                }
8338                                                break;
8339                                        case 6:
8340                                                {
8341                                                setState(1019);
8342                                                td();
8343                                                }
8344                                                break;
8345                                        case 7:
8346                                                {
8347                                                setState(1020);
8348                                                th();
8349                                                }
8350                                                break;
8351                                        case 8:
8352                                                {
8353                                                setState(1021);
8354                                                body();
8355                                                }
8356                                                break;
8357                                        case 9:
8358                                                {
8359                                                setState(1022);
8360                                                colgroup();
8361                                                }
8362                                                break;
8363                                        case 10:
8364                                                {
8365                                                setState(1023);
8366                                                dd();
8367                                                }
8368                                                break;
8369                                        case 11:
8370                                                {
8371                                                setState(1024);
8372                                                dt();
8373                                                }
8374                                                break;
8375                                        case 12:
8376                                                {
8377                                                setState(1025);
8378                                                head();
8379                                                }
8380                                                break;
8381                                        case 13:
8382                                                {
8383                                                setState(1026);
8384                                                option();
8385                                                }
8386                                                break;
8387                                        case 14:
8388                                                {
8389                                                setState(1027);
8390                                                tbody();
8391                                                }
8392                                                break;
8393                                        case 15:
8394                                                {
8395                                                setState(1028);
8396                                                thead();
8397                                                }
8398                                                break;
8399                                        case 16:
8400                                                {
8401                                                setState(1029);
8402                                                tfoot();
8403                                                }
8404                                                break;
8405                                        case 17:
8406                                                {
8407                                                setState(1030);
8408                                                pTagStart(true);
8409                                                }
8410                                                break;
8411                                        case 18:
8412                                                {
8413                                                setState(1031);
8414                                                liTagStart(true);
8415                                                }
8416                                                break;
8417                                        case 19:
8418                                                {
8419                                                setState(1032);
8420                                                trTagStart(true);
8421                                                }
8422                                                break;
8423                                        case 20:
8424                                                {
8425                                                setState(1033);
8426                                                tdTagStart(true);
8427                                                }
8428                                                break;
8429                                        case 21:
8430                                                {
8431                                                setState(1034);
8432                                                thTagStart(true);
8433                                                }
8434                                                break;
8435                                        case 22:
8436                                                {
8437                                                setState(1035);
8438                                                bodyTagStart(true);
8439                                                }
8440                                                break;
8441                                        case 23:
8442                                                {
8443                                                setState(1036);
8444                                                colgroupTagStart(true);
8445                                                }
8446                                                break;
8447                                        case 24:
8448                                                {
8449                                                setState(1037);
8450                                                ddTagStart(true);
8451                                                }
8452                                                break;
8453                                        case 25:
8454                                                {
8455                                                setState(1038);
8456                                                dtTagStart(true);
8457                                                }
8458                                                break;
8459                                        case 26:
8460                                                {
8461                                                setState(1039);
8462                                                headTagStart(true);
8463                                                }
8464                                                break;
8465                                        case 27:
8466                                                {
8467                                                setState(1040);
8468                                                optionTagStart(true);
8469                                                }
8470                                                break;
8471                                        case 28:
8472                                                {
8473                                                setState(1041);
8474                                                tbodyTagStart(true);
8475                                                }
8476                                                break;
8477                                        case 29:
8478                                                {
8479                                                setState(1042);
8480                                                theadTagStart(true);
8481                                                }
8482                                                break;
8483                                        case 30:
8484                                                {
8485                                                setState(1043);
8486                                                tfootTagStart(true);
8487                                                }
8488                                                break;
8489                                        case 31:
8490                                                {
8491                                                {
8492                                                setState(1044);
8493                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8494                                                setState(1045);
8495                                                match(LEADING_ASTERISK);
8496                                                }
8497                                                }
8498                                                break;
8499                                        case 32:
8500                                                {
8501                                                setState(1046);
8502                                                htmlComment();
8503                                                }
8504                                                break;
8505                                        case 33:
8506                                                {
8507                                                setState(1047);
8508                                                match(CDATA);
8509                                                }
8510                                                break;
8511                                        case 34:
8512                                                {
8513                                                setState(1048);
8514                                                match(NEWLINE);
8515                                                }
8516                                                break;
8517                                        case 35:
8518                                                {
8519                                                setState(1049);
8520                                                text();
8521                                                }
8522                                                break;
8523                                        case 36:
8524                                                {
8525                                                setState(1050);
8526                                                javadocInlineTag();
8527                                                }
8528                                                break;
8529                                        }
8530                                        } 
8531                                }
8532                                setState(1055);
8533                                _errHandler.sync(this);
8534                                _alt = getInterpreter().adaptivePredict(_input,68,_ctx);
8535                        }
8536                        setState(1056);
8537                        htmlTagEnd();
8538                        }
8539                }
8540                catch (RecognitionException re) {
8541                        _localctx.exception = re;
8542                        _errHandler.reportError(this, re);
8543                        _errHandler.recover(this, re);
8544                }
8545                finally {
8546                        exitRule();
8547                }
8548                return _localctx;
8549        }
8550
8551        public static class OptionTagStartContext extends ParserRuleContext {
8552                public boolean isNonTight;
8553                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
8554                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8555                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
8556                public List<AttributeContext> attribute() {
8557                        return getRuleContexts(AttributeContext.class);
8558                }
8559                public AttributeContext attribute(int i) {
8560                        return getRuleContext(AttributeContext.class,i);
8561                }
8562                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8563                public TerminalNode NEWLINE(int i) {
8564                        return getToken(JavadocParser.NEWLINE, i);
8565                }
8566                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8567                public TerminalNode LEADING_ASTERISK(int i) {
8568                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8569                }
8570                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8571                public TerminalNode WS(int i) {
8572                        return getToken(JavadocParser.WS, i);
8573                }
8574                public OptionTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
8575                public OptionTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) {
8576                        super(parent, invokingState);
8577                        this.isNonTight = isNonTight;
8578                }
8579                @Override public int getRuleIndex() { return RULE_optionTagStart; }
8580        }
8581
8582        public final OptionTagStartContext optionTagStart(boolean isNonTight) throws RecognitionException {
8583                OptionTagStartContext _localctx = new OptionTagStartContext(_ctx, getState(), isNonTight);
8584                enterRule(_localctx, 78, RULE_optionTagStart);
8585                int _la;
8586                try {
8587                        enterOuterAlt(_localctx, 1);
8588                        {
8589                        setState(1058);
8590                        match(START);
8591                        setState(1059);
8592                        match(OPTION_HTML_TAG_NAME);
8593                        setState(1066);
8594                        _errHandler.sync(this);
8595                        _la = _input.LA(1);
8596                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8597                                {
8598                                setState(1064);
8599                                _errHandler.sync(this);
8600                                switch (_input.LA(1)) {
8601                                case HTML_TAG_NAME:
8602                                        {
8603                                        setState(1060);
8604                                        attribute();
8605                                        }
8606                                        break;
8607                                case NEWLINE:
8608                                        {
8609                                        setState(1061);
8610                                        match(NEWLINE);
8611                                        }
8612                                        break;
8613                                case LEADING_ASTERISK:
8614                                        {
8615                                        setState(1062);
8616                                        match(LEADING_ASTERISK);
8617                                        }
8618                                        break;
8619                                case WS:
8620                                        {
8621                                        setState(1063);
8622                                        match(WS);
8623                                        }
8624                                        break;
8625                                default:
8626                                        throw new NoViableAltException(this);
8627                                }
8628                                }
8629                                setState(1068);
8630                                _errHandler.sync(this);
8631                                _la = _input.LA(1);
8632                        }
8633                        setState(1069);
8634                        match(END);
8635                        }
8636                        _ctx.stop = _input.LT(-1);
8637
8638                            if (isNonTight && nonTightTagStartContext == null) {
8639                                nonTightTagStartContext = _localctx;
8640                            }
8641
8642                }
8643                catch (RecognitionException re) {
8644                        _localctx.exception = re;
8645                        _errHandler.reportError(this, re);
8646                        _errHandler.recover(this, re);
8647                }
8648                finally {
8649                        exitRule();
8650                }
8651                return _localctx;
8652        }
8653
8654        public static class OptionTagEndContext extends ParserRuleContext {
8655                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
8656                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8657                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8658                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
8659                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8660                public TerminalNode NEWLINE(int i) {
8661                        return getToken(JavadocParser.NEWLINE, i);
8662                }
8663                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8664                public TerminalNode LEADING_ASTERISK(int i) {
8665                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8666                }
8667                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8668                public TerminalNode WS(int i) {
8669                        return getToken(JavadocParser.WS, i);
8670                }
8671                public OptionTagEndContext(ParserRuleContext parent, int invokingState) {
8672                        super(parent, invokingState);
8673                }
8674                @Override public int getRuleIndex() { return RULE_optionTagEnd; }
8675        }
8676
8677        public final OptionTagEndContext optionTagEnd() throws RecognitionException {
8678                OptionTagEndContext _localctx = new OptionTagEndContext(_ctx, getState());
8679                enterRule(_localctx, 80, RULE_optionTagEnd);
8680                int _la;
8681                try {
8682                        enterOuterAlt(_localctx, 1);
8683                        {
8684                        setState(1071);
8685                        match(START);
8686                        setState(1072);
8687                        match(SLASH);
8688                        setState(1073);
8689                        match(OPTION_HTML_TAG_NAME);
8690                        setState(1077);
8691                        _errHandler.sync(this);
8692                        _la = _input.LA(1);
8693                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8694                                {
8695                                {
8696                                setState(1074);
8697                                _la = _input.LA(1);
8698                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8699                                _errHandler.recoverInline(this);
8700                                }
8701                                else {
8702                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
8703                                        _errHandler.reportMatch(this);
8704                                        consume();
8705                                }
8706                                }
8707                                }
8708                                setState(1079);
8709                                _errHandler.sync(this);
8710                                _la = _input.LA(1);
8711                        }
8712                        setState(1080);
8713                        match(END);
8714                        }
8715                }
8716                catch (RecognitionException re) {
8717                        _localctx.exception = re;
8718                        _errHandler.reportError(this, re);
8719                        _errHandler.recover(this, re);
8720                }
8721                finally {
8722                        exitRule();
8723                }
8724                return _localctx;
8725        }
8726
8727        public static class OptionContext extends ParserRuleContext {
8728                public OptionTagStartContext optionTagStart() {
8729                        return getRuleContext(OptionTagStartContext.class,0);
8730                }
8731                public OptionTagEndContext optionTagEnd() {
8732                        return getRuleContext(OptionTagEndContext.class,0);
8733                }
8734                public List<HtmlTagContext> htmlTag() {
8735                        return getRuleContexts(HtmlTagContext.class);
8736                }
8737                public HtmlTagContext htmlTag(int i) {
8738                        return getRuleContext(HtmlTagContext.class,i);
8739                }
8740                public List<SingletonElementContext> singletonElement() {
8741                        return getRuleContexts(SingletonElementContext.class);
8742                }
8743                public SingletonElementContext singletonElement(int i) {
8744                        return getRuleContext(SingletonElementContext.class,i);
8745                }
8746                public List<ParagraphContext> paragraph() {
8747                        return getRuleContexts(ParagraphContext.class);
8748                }
8749                public ParagraphContext paragraph(int i) {
8750                        return getRuleContext(ParagraphContext.class,i);
8751                }
8752                public List<LiContext> li() {
8753                        return getRuleContexts(LiContext.class);
8754                }
8755                public LiContext li(int i) {
8756                        return getRuleContext(LiContext.class,i);
8757                }
8758                public List<TrContext> tr() {
8759                        return getRuleContexts(TrContext.class);
8760                }
8761                public TrContext tr(int i) {
8762                        return getRuleContext(TrContext.class,i);
8763                }
8764                public List<TdContext> td() {
8765                        return getRuleContexts(TdContext.class);
8766                }
8767                public TdContext td(int i) {
8768                        return getRuleContext(TdContext.class,i);
8769                }
8770                public List<ThContext> th() {
8771                        return getRuleContexts(ThContext.class);
8772                }
8773                public ThContext th(int i) {
8774                        return getRuleContext(ThContext.class,i);
8775                }
8776                public List<BodyContext> body() {
8777                        return getRuleContexts(BodyContext.class);
8778                }
8779                public BodyContext body(int i) {
8780                        return getRuleContext(BodyContext.class,i);
8781                }
8782                public List<ColgroupContext> colgroup() {
8783                        return getRuleContexts(ColgroupContext.class);
8784                }
8785                public ColgroupContext colgroup(int i) {
8786                        return getRuleContext(ColgroupContext.class,i);
8787                }
8788                public List<DdContext> dd() {
8789                        return getRuleContexts(DdContext.class);
8790                }
8791                public DdContext dd(int i) {
8792                        return getRuleContext(DdContext.class,i);
8793                }
8794                public List<DtContext> dt() {
8795                        return getRuleContexts(DtContext.class);
8796                }
8797                public DtContext dt(int i) {
8798                        return getRuleContext(DtContext.class,i);
8799                }
8800                public List<HeadContext> head() {
8801                        return getRuleContexts(HeadContext.class);
8802                }
8803                public HeadContext head(int i) {
8804                        return getRuleContext(HeadContext.class,i);
8805                }
8806                public List<HtmlContext> html() {
8807                        return getRuleContexts(HtmlContext.class);
8808                }
8809                public HtmlContext html(int i) {
8810                        return getRuleContext(HtmlContext.class,i);
8811                }
8812                public List<TbodyContext> tbody() {
8813                        return getRuleContexts(TbodyContext.class);
8814                }
8815                public TbodyContext tbody(int i) {
8816                        return getRuleContext(TbodyContext.class,i);
8817                }
8818                public List<TheadContext> thead() {
8819                        return getRuleContexts(TheadContext.class);
8820                }
8821                public TheadContext thead(int i) {
8822                        return getRuleContext(TheadContext.class,i);
8823                }
8824                public List<TfootContext> tfoot() {
8825                        return getRuleContexts(TfootContext.class);
8826                }
8827                public TfootContext tfoot(int i) {
8828                        return getRuleContext(TfootContext.class,i);
8829                }
8830                public List<PTagStartContext> pTagStart() {
8831                        return getRuleContexts(PTagStartContext.class);
8832                }
8833                public PTagStartContext pTagStart(int i) {
8834                        return getRuleContext(PTagStartContext.class,i);
8835                }
8836                public List<LiTagStartContext> liTagStart() {
8837                        return getRuleContexts(LiTagStartContext.class);
8838                }
8839                public LiTagStartContext liTagStart(int i) {
8840                        return getRuleContext(LiTagStartContext.class,i);
8841                }
8842                public List<TrTagStartContext> trTagStart() {
8843                        return getRuleContexts(TrTagStartContext.class);
8844                }
8845                public TrTagStartContext trTagStart(int i) {
8846                        return getRuleContext(TrTagStartContext.class,i);
8847                }
8848                public List<TdTagStartContext> tdTagStart() {
8849                        return getRuleContexts(TdTagStartContext.class);
8850                }
8851                public TdTagStartContext tdTagStart(int i) {
8852                        return getRuleContext(TdTagStartContext.class,i);
8853                }
8854                public List<ThTagStartContext> thTagStart() {
8855                        return getRuleContexts(ThTagStartContext.class);
8856                }
8857                public ThTagStartContext thTagStart(int i) {
8858                        return getRuleContext(ThTagStartContext.class,i);
8859                }
8860                public List<BodyTagStartContext> bodyTagStart() {
8861                        return getRuleContexts(BodyTagStartContext.class);
8862                }
8863                public BodyTagStartContext bodyTagStart(int i) {
8864                        return getRuleContext(BodyTagStartContext.class,i);
8865                }
8866                public List<ColgroupTagStartContext> colgroupTagStart() {
8867                        return getRuleContexts(ColgroupTagStartContext.class);
8868                }
8869                public ColgroupTagStartContext colgroupTagStart(int i) {
8870                        return getRuleContext(ColgroupTagStartContext.class,i);
8871                }
8872                public List<DdTagStartContext> ddTagStart() {
8873                        return getRuleContexts(DdTagStartContext.class);
8874                }
8875                public DdTagStartContext ddTagStart(int i) {
8876                        return getRuleContext(DdTagStartContext.class,i);
8877                }
8878                public List<DtTagStartContext> dtTagStart() {
8879                        return getRuleContexts(DtTagStartContext.class);
8880                }
8881                public DtTagStartContext dtTagStart(int i) {
8882                        return getRuleContext(DtTagStartContext.class,i);
8883                }
8884                public List<HeadTagStartContext> headTagStart() {
8885                        return getRuleContexts(HeadTagStartContext.class);
8886                }
8887                public HeadTagStartContext headTagStart(int i) {
8888                        return getRuleContext(HeadTagStartContext.class,i);
8889                }
8890                public List<HtmlTagStartContext> htmlTagStart() {
8891                        return getRuleContexts(HtmlTagStartContext.class);
8892                }
8893                public HtmlTagStartContext htmlTagStart(int i) {
8894                        return getRuleContext(HtmlTagStartContext.class,i);
8895                }
8896                public List<TbodyTagStartContext> tbodyTagStart() {
8897                        return getRuleContexts(TbodyTagStartContext.class);
8898                }
8899                public TbodyTagStartContext tbodyTagStart(int i) {
8900                        return getRuleContext(TbodyTagStartContext.class,i);
8901                }
8902                public List<TheadTagStartContext> theadTagStart() {
8903                        return getRuleContexts(TheadTagStartContext.class);
8904                }
8905                public TheadTagStartContext theadTagStart(int i) {
8906                        return getRuleContext(TheadTagStartContext.class,i);
8907                }
8908                public List<TfootTagStartContext> tfootTagStart() {
8909                        return getRuleContexts(TfootTagStartContext.class);
8910                }
8911                public TfootTagStartContext tfootTagStart(int i) {
8912                        return getRuleContext(TfootTagStartContext.class,i);
8913                }
8914                public List<HtmlCommentContext> htmlComment() {
8915                        return getRuleContexts(HtmlCommentContext.class);
8916                }
8917                public HtmlCommentContext htmlComment(int i) {
8918                        return getRuleContext(HtmlCommentContext.class,i);
8919                }
8920                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8921                public TerminalNode CDATA(int i) {
8922                        return getToken(JavadocParser.CDATA, i);
8923                }
8924                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8925                public TerminalNode NEWLINE(int i) {
8926                        return getToken(JavadocParser.NEWLINE, i);
8927                }
8928                public List<TextContext> text() {
8929                        return getRuleContexts(TextContext.class);
8930                }
8931                public TextContext text(int i) {
8932                        return getRuleContext(TextContext.class,i);
8933                }
8934                public List<JavadocInlineTagContext> javadocInlineTag() {
8935                        return getRuleContexts(JavadocInlineTagContext.class);
8936                }
8937                public JavadocInlineTagContext javadocInlineTag(int i) {
8938                        return getRuleContext(JavadocInlineTagContext.class,i);
8939                }
8940                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8941                public TerminalNode LEADING_ASTERISK(int i) {
8942                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8943                }
8944                public OptionContext(ParserRuleContext parent, int invokingState) {
8945                        super(parent, invokingState);
8946                }
8947                @Override public int getRuleIndex() { return RULE_option; }
8948        }
8949
8950        public final OptionContext option() throws RecognitionException {
8951                OptionContext _localctx = new OptionContext(_ctx, getState());
8952                enterRule(_localctx, 82, RULE_option);
8953                try {
8954                        int _alt;
8955                        enterOuterAlt(_localctx, 1);
8956                        {
8957                        setState(1082);
8958                        optionTagStart(false);
8959                        setState(1122);
8960                        _errHandler.sync(this);
8961                        _alt = getInterpreter().adaptivePredict(_input,73,_ctx);
8962                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8963                                if ( _alt==1 ) {
8964                                        {
8965                                        setState(1120);
8966                                        _errHandler.sync(this);
8967                                        switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
8968                                        case 1:
8969                                                {
8970                                                setState(1083);
8971                                                htmlTag();
8972                                                }
8973                                                break;
8974                                        case 2:
8975                                                {
8976                                                setState(1084);
8977                                                singletonElement();
8978                                                }
8979                                                break;
8980                                        case 3:
8981                                                {
8982                                                setState(1085);
8983                                                paragraph();
8984                                                }
8985                                                break;
8986                                        case 4:
8987                                                {
8988                                                setState(1086);
8989                                                li();
8990                                                }
8991                                                break;
8992                                        case 5:
8993                                                {
8994                                                setState(1087);
8995                                                tr();
8996                                                }
8997                                                break;
8998                                        case 6:
8999                                                {
9000                                                setState(1088);
9001                                                td();
9002                                                }
9003                                                break;
9004                                        case 7:
9005                                                {
9006                                                setState(1089);
9007                                                th();
9008                                                }
9009                                                break;
9010                                        case 8:
9011                                                {
9012                                                setState(1090);
9013                                                body();
9014                                                }
9015                                                break;
9016                                        case 9:
9017                                                {
9018                                                setState(1091);
9019                                                colgroup();
9020                                                }
9021                                                break;
9022                                        case 10:
9023                                                {
9024                                                setState(1092);
9025                                                dd();
9026                                                }
9027                                                break;
9028                                        case 11:
9029                                                {
9030                                                setState(1093);
9031                                                dt();
9032                                                }
9033                                                break;
9034                                        case 12:
9035                                                {
9036                                                setState(1094);
9037                                                head();
9038                                                }
9039                                                break;
9040                                        case 13:
9041                                                {
9042                                                setState(1095);
9043                                                html();
9044                                                }
9045                                                break;
9046                                        case 14:
9047                                                {
9048                                                setState(1096);
9049                                                tbody();
9050                                                }
9051                                                break;
9052                                        case 15:
9053                                                {
9054                                                setState(1097);
9055                                                thead();
9056                                                }
9057                                                break;
9058                                        case 16:
9059                                                {
9060                                                setState(1098);
9061                                                tfoot();
9062                                                }
9063                                                break;
9064                                        case 17:
9065                                                {
9066                                                setState(1099);
9067                                                pTagStart(true);
9068                                                }
9069                                                break;
9070                                        case 18:
9071                                                {
9072                                                setState(1100);
9073                                                liTagStart(true);
9074                                                }
9075                                                break;
9076                                        case 19:
9077                                                {
9078                                                setState(1101);
9079                                                trTagStart(true);
9080                                                }
9081                                                break;
9082                                        case 20:
9083                                                {
9084                                                setState(1102);
9085                                                tdTagStart(true);
9086                                                }
9087                                                break;
9088                                        case 21:
9089                                                {
9090                                                setState(1103);
9091                                                thTagStart(true);
9092                                                }
9093                                                break;
9094                                        case 22:
9095                                                {
9096                                                setState(1104);
9097                                                bodyTagStart(true);
9098                                                }
9099                                                break;
9100                                        case 23:
9101                                                {
9102                                                setState(1105);
9103                                                colgroupTagStart(true);
9104                                                }
9105                                                break;
9106                                        case 24:
9107                                                {
9108                                                setState(1106);
9109                                                ddTagStart(true);
9110                                                }
9111                                                break;
9112                                        case 25:
9113                                                {
9114                                                setState(1107);
9115                                                dtTagStart(true);
9116                                                }
9117                                                break;
9118                                        case 26:
9119                                                {
9120                                                setState(1108);
9121                                                headTagStart(true);
9122                                                }
9123                                                break;
9124                                        case 27:
9125                                                {
9126                                                setState(1109);
9127                                                htmlTagStart(true);
9128                                                }
9129                                                break;
9130                                        case 28:
9131                                                {
9132                                                setState(1110);
9133                                                tbodyTagStart(true);
9134                                                }
9135                                                break;
9136                                        case 29:
9137                                                {
9138                                                setState(1111);
9139                                                theadTagStart(true);
9140                                                }
9141                                                break;
9142                                        case 30:
9143                                                {
9144                                                setState(1112);
9145                                                tfootTagStart(true);
9146                                                }
9147                                                break;
9148                                        case 31:
9149                                                {
9150                                                {
9151                                                setState(1113);
9152                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9153                                                setState(1114);
9154                                                match(LEADING_ASTERISK);
9155                                                }
9156                                                }
9157                                                break;
9158                                        case 32:
9159                                                {
9160                                                setState(1115);
9161                                                htmlComment();
9162                                                }
9163                                                break;
9164                                        case 33:
9165                                                {
9166                                                setState(1116);
9167                                                match(CDATA);
9168                                                }
9169                                                break;
9170                                        case 34:
9171                                                {
9172                                                setState(1117);
9173                                                match(NEWLINE);
9174                                                }
9175                                                break;
9176                                        case 35:
9177                                                {
9178                                                setState(1118);
9179                                                text();
9180                                                }
9181                                                break;
9182                                        case 36:
9183                                                {
9184                                                setState(1119);
9185                                                javadocInlineTag();
9186                                                }
9187                                                break;
9188                                        }
9189                                        } 
9190                                }
9191                                setState(1124);
9192                                _errHandler.sync(this);
9193                                _alt = getInterpreter().adaptivePredict(_input,73,_ctx);
9194                        }
9195                        setState(1125);
9196                        optionTagEnd();
9197                        }
9198                }
9199                catch (RecognitionException re) {
9200                        _localctx.exception = re;
9201                        _errHandler.reportError(this, re);
9202                        _errHandler.recover(this, re);
9203                }
9204                finally {
9205                        exitRule();
9206                }
9207                return _localctx;
9208        }
9209
9210        public static class TbodyTagStartContext extends ParserRuleContext {
9211                public boolean isNonTight;
9212                public TerminalNode START() { return getToken(JavadocParser.START, 0); }
9213                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9214                public TerminalNode END() { return getToken(JavadocParser.END, 0); }
9215                public List<AttributeContext> attribute() {
9216                        return getRuleContexts(AttributeContext.class);
9217                }
9218                public AttributeContext attribute(int i) {
9219                        return getRuleContext(AttributeContext.class,i);