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