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