001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.8
002package com.puppycrawl.tools.checkstyle.grammars.javadoc;
003import org.antlr.v4.runtime.atn.*;
004import org.antlr.v4.runtime.dfa.DFA;
005import org.antlr.v4.runtime.*;
006import org.antlr.v4.runtime.misc.*;
007import org.antlr.v4.runtime.tree.*;
008import java.util.List;
009import java.util.Iterator;
010import java.util.ArrayList;
011
012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
013public class JavadocParser extends Parser {
014        static { RuntimeMetaData.checkVersion("4.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, CDATA=3, WS=4, OPEN=5, NEWLINE=6, 
021                AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 
022                RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 
023                SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 
024                JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 
025                LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 
026                STRING=27, PACKAGE=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 
027                LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 
028                Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 
029                DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 
030                LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, CLOSE=55, 
031                SLASH_CLOSE=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 
032                TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 
033                COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 
034                HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 
035                TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 
036                BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 
037                COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 
038                INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 
039                META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, HTML_TAG_NAME=87, Char11=88, 
040                ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91;
041        public static final int
042                RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 
043                RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 
044                RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 
045                RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 
046                RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 
047                RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 
048                RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 
049                RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 
050                RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 
051                RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 
052                RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 
053                RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 
054                RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 
055                RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 
056                RULE_baseTag = 54, RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 
057                RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 
058                RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 
059                RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 
060                RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 
061                RULE_htmlComment = 73, RULE_text = 74;
062        private static String[] makeRuleNames() {
063                return new String[] {
064                        "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 
065                        "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 
066                        "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 
067                        "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 
068                        "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 
069                        "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 
070                        "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 
071                        "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 
072                        "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 
073                        "singletonTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", 
074                        "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 
075                        "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 
076                        "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text"
077                };
078        }
079        public static final String[] ruleNames = makeRuleNames();
080
081        private static String[] makeLiteralNames() {
082                return new String[] {
083                        null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 
084                        null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 
085                        null, "'@version'", null, null, null, "'include'", "'exclude'", null, 
086                        null, null, null, null, "'.'", null, null, null, null, "'('", "')'", 
087                        null, "','", null, null, null, null, null, null, null, null, "'@docRoot'", 
088                        "'@inheritDoc'", "'@link'", "'@linkplain'", null, "'@value'", null, null, 
089                        null, null, null, "'/'", "'='", null, null, null, null, null, null, null, 
090                        null, null, null, null, null, null, null, null, null, null, null, null, 
091                        null, null, null, null, null, null, null, null, null, null, null, null, 
092                        null, "'-->'"
093                };
094        }
095        private static final String[] _LITERAL_NAMES = makeLiteralNames();
096        private static String[] makeSymbolicNames() {
097                return new String[] {
098                        null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 
099                        "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 
100                        "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 
101                        "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 
102                        "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", 
103                        "LITERAL_INCLUDE", "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", 
104                        "STRING", "PACKAGE", "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", 
105                        "RIGHT_BRACE", "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", 
106                        "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", 
107                        "INHERIT_DOC_LITERAL", "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", 
108                        "VALUE_LITERAL", "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", 
109                        "SLASH", "EQUALS", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", 
110                        "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", 
111                        "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", 
112                        "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", 
113                        "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", "BASEFONT_HTML_TAG_NAME", 
114                        "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", 
115                        "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 
116                        "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "HTML_TAG_NAME", 
117                        "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END"
118                };
119        }
120        private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
121        public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
122
123        /**
124         * @deprecated Use {@link #VOCABULARY} instead.
125         */
126        @Deprecated
127        public static final String[] tokenNames;
128        static {
129                tokenNames = new String[_SYMBOLIC_NAMES.length];
130                for (int i = 0; i < tokenNames.length; i++) {
131                        tokenNames[i] = VOCABULARY.getLiteralName(i);
132                        if (tokenNames[i] == null) {
133                                tokenNames[i] = VOCABULARY.getSymbolicName(i);
134                        }
135
136                        if (tokenNames[i] == null) {
137                                tokenNames[i] = "<INVALID>";
138                        }
139                }
140        }
141
142        @Override
143        @Deprecated
144        public String[] getTokenNames() {
145                return tokenNames;
146        }
147
148        @Override
149
150        public Vocabulary getVocabulary() {
151                return VOCABULARY;
152        }
153
154        @Override
155        public String getGrammarFileName() { return "JavadocParser.g4"; }
156
157        @Override
158        public String[] getRuleNames() { return ruleNames; }
159
160        @Override
161        public String getSerializedATN() { return _serializedATN; }
162
163        @Override
164        public ATN getATN() { return _ATN; }
165
166
167            boolean isNextJavadocTag() {
168                int token1 = _input.LA(2);
169                int token2 = _input.LA(3);
170                return isJavadocTag(token1)
171                    || (token1 == WS && isJavadocTag(token2));
172            }
173
174            boolean isJavadocTag(int type) {
175                switch(type) {
176                    case AUTHOR_LITERAL:
177                    case DEPRECATED_LITERAL:
178                    case EXCEPTION_LITERAL:
179                    case PARAM_LITERAL:
180                    case RETURN_LITERAL:
181                    case SEE_LITERAL:
182                    case SERIAL_LITERAL:
183                    case SERIAL_FIELD_LITERAL:
184                    case SERIAL_DATA_LITERAL:
185                    case SINCE_LITERAL:
186                    case THROWS_LITERAL:
187                    case VERSION_LITERAL:
188                    case CUSTOM_NAME:
189                        return true;
190                    default:
191                        return false;
192                }
193            }
194
195              boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) {
196                    String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
197                    String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
198                    System.out.println(openTag + " - " + closeTag);
199                    return openTag.equals(closeTag);
200              }
201
202        public JavadocParser(TokenStream input) {
203                super(input);
204                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
205        }
206
207        public static class JavadocContext extends ParserRuleContext {
208                public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
209                public List<HtmlElementContext> htmlElement() {
210                        return getRuleContexts(HtmlElementContext.class);
211                }
212                public HtmlElementContext htmlElement(int i) {
213                        return getRuleContext(HtmlElementContext.class,i);
214                }
215                public List<HtmlCommentContext> htmlComment() {
216                        return getRuleContexts(HtmlCommentContext.class);
217                }
218                public HtmlCommentContext htmlComment(int i) {
219                        return getRuleContext(HtmlCommentContext.class,i);
220                }
221                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
222                public TerminalNode CDATA(int i) {
223                        return getToken(JavadocParser.CDATA, i);
224                }
225                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
226                public TerminalNode NEWLINE(int i) {
227                        return getToken(JavadocParser.NEWLINE, i);
228                }
229                public List<TextContext> text() {
230                        return getRuleContexts(TextContext.class);
231                }
232                public TextContext text(int i) {
233                        return getRuleContext(TextContext.class,i);
234                }
235                public List<JavadocInlineTagContext> javadocInlineTag() {
236                        return getRuleContexts(JavadocInlineTagContext.class);
237                }
238                public JavadocInlineTagContext javadocInlineTag(int i) {
239                        return getRuleContext(JavadocInlineTagContext.class,i);
240                }
241                public List<JavadocTagContext> javadocTag() {
242                        return getRuleContexts(JavadocTagContext.class);
243                }
244                public JavadocTagContext javadocTag(int i) {
245                        return getRuleContext(JavadocTagContext.class,i);
246                }
247                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
248                public TerminalNode LEADING_ASTERISK(int i) {
249                        return getToken(JavadocParser.LEADING_ASTERISK, i);
250                }
251                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
252                public TerminalNode WS(int i) {
253                        return getToken(JavadocParser.WS, i);
254                }
255                public JavadocContext(ParserRuleContext parent, int invokingState) {
256                        super(parent, invokingState);
257                }
258                @Override public int getRuleIndex() { return RULE_javadoc; }
259                @Override
260                public void enterRule(ParseTreeListener listener) {
261                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this);
262                }
263                @Override
264                public void exitRule(ParseTreeListener listener) {
265                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this);
266                }
267                @Override
268                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
269                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this);
270                        else return visitor.visitChildren(this);
271                }
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(160);
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(158);
289                                        _errHandler.sync(this);
290                                        switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
291                                        case 1:
292                                                {
293                                                setState(150);
294                                                htmlElement();
295                                                }
296                                                break;
297                                        case 2:
298                                                {
299                                                {
300                                                setState(151);
301                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
302                                                setState(152);
303                                                match(LEADING_ASTERISK);
304                                                }
305                                                }
306                                                break;
307                                        case 3:
308                                                {
309                                                setState(153);
310                                                htmlComment();
311                                                }
312                                                break;
313                                        case 4:
314                                                {
315                                                setState(154);
316                                                match(CDATA);
317                                                }
318                                                break;
319                                        case 5:
320                                                {
321                                                setState(155);
322                                                match(NEWLINE);
323                                                }
324                                                break;
325                                        case 6:
326                                                {
327                                                setState(156);
328                                                text();
329                                                }
330                                                break;
331                                        case 7:
332                                                {
333                                                setState(157);
334                                                javadocInlineTag();
335                                                }
336                                                break;
337                                        }
338                                        } 
339                                }
340                                setState(162);
341                                _errHandler.sync(this);
342                                _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
343                        }
344                        setState(175);
345                        _errHandler.sync(this);
346                        _la = _input.LA(1);
347                        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)) {
348                                {
349                                {
350                                setState(164);
351                                _errHandler.sync(this);
352                                _la = _input.LA(1);
353                                if (_la==LEADING_ASTERISK) {
354                                        {
355                                        setState(163);
356                                        match(LEADING_ASTERISK);
357                                        }
358                                }
359
360                                setState(169);
361                                _errHandler.sync(this);
362                                _la = _input.LA(1);
363                                while (_la==WS) {
364                                        {
365                                        {
366                                        setState(166);
367                                        match(WS);
368                                        }
369                                        }
370                                        setState(171);
371                                        _errHandler.sync(this);
372                                        _la = _input.LA(1);
373                                }
374                                setState(172);
375                                javadocTag();
376                                }
377                                }
378                                setState(177);
379                                _errHandler.sync(this);
380                                _la = _input.LA(1);
381                        }
382                        setState(178);
383                        match(EOF);
384                        }
385                }
386                catch (RecognitionException re) {
387                        _localctx.exception = re;
388                        _errHandler.reportError(this, re);
389                        _errHandler.recover(this, re);
390                }
391                finally {
392                        exitRule();
393                }
394                return _localctx;
395        }
396
397        public static class HtmlElementContext extends ParserRuleContext {
398                public HtmlTagContext htmlTag() {
399                        return getRuleContext(HtmlTagContext.class,0);
400                }
401                public SingletonElementContext singletonElement() {
402                        return getRuleContext(SingletonElementContext.class,0);
403                }
404                public ParagraphContext paragraph() {
405                        return getRuleContext(ParagraphContext.class,0);
406                }
407                public LiContext li() {
408                        return getRuleContext(LiContext.class,0);
409                }
410                public TrContext tr() {
411                        return getRuleContext(TrContext.class,0);
412                }
413                public TdContext td() {
414                        return getRuleContext(TdContext.class,0);
415                }
416                public ThContext th() {
417                        return getRuleContext(ThContext.class,0);
418                }
419                public BodyContext body() {
420                        return getRuleContext(BodyContext.class,0);
421                }
422                public ColgroupContext colgroup() {
423                        return getRuleContext(ColgroupContext.class,0);
424                }
425                public DdContext dd() {
426                        return getRuleContext(DdContext.class,0);
427                }
428                public DtContext dt() {
429                        return getRuleContext(DtContext.class,0);
430                }
431                public HeadContext head() {
432                        return getRuleContext(HeadContext.class,0);
433                }
434                public HtmlContext html() {
435                        return getRuleContext(HtmlContext.class,0);
436                }
437                public OptionContext option() {
438                        return getRuleContext(OptionContext.class,0);
439                }
440                public TbodyContext tbody() {
441                        return getRuleContext(TbodyContext.class,0);
442                }
443                public TheadContext thead() {
444                        return getRuleContext(TheadContext.class,0);
445                }
446                public TfootContext tfoot() {
447                        return getRuleContext(TfootContext.class,0);
448                }
449                public PTagOpenContext pTagOpen() {
450                        return getRuleContext(PTagOpenContext.class,0);
451                }
452                public LiTagOpenContext liTagOpen() {
453                        return getRuleContext(LiTagOpenContext.class,0);
454                }
455                public TrTagOpenContext trTagOpen() {
456                        return getRuleContext(TrTagOpenContext.class,0);
457                }
458                public TdTagOpenContext tdTagOpen() {
459                        return getRuleContext(TdTagOpenContext.class,0);
460                }
461                public ThTagOpenContext thTagOpen() {
462                        return getRuleContext(ThTagOpenContext.class,0);
463                }
464                public BodyTagOpenContext bodyTagOpen() {
465                        return getRuleContext(BodyTagOpenContext.class,0);
466                }
467                public ColgroupTagOpenContext colgroupTagOpen() {
468                        return getRuleContext(ColgroupTagOpenContext.class,0);
469                }
470                public DdTagOpenContext ddTagOpen() {
471                        return getRuleContext(DdTagOpenContext.class,0);
472                }
473                public DtTagOpenContext dtTagOpen() {
474                        return getRuleContext(DtTagOpenContext.class,0);
475                }
476                public HeadTagOpenContext headTagOpen() {
477                        return getRuleContext(HeadTagOpenContext.class,0);
478                }
479                public HtmlTagOpenContext htmlTagOpen() {
480                        return getRuleContext(HtmlTagOpenContext.class,0);
481                }
482                public OptionTagOpenContext optionTagOpen() {
483                        return getRuleContext(OptionTagOpenContext.class,0);
484                }
485                public TbodyTagOpenContext tbodyTagOpen() {
486                        return getRuleContext(TbodyTagOpenContext.class,0);
487                }
488                public TheadTagOpenContext theadTagOpen() {
489                        return getRuleContext(TheadTagOpenContext.class,0);
490                }
491                public TfootTagOpenContext tfootTagOpen() {
492                        return getRuleContext(TfootTagOpenContext.class,0);
493                }
494                public PTagCloseContext pTagClose() {
495                        return getRuleContext(PTagCloseContext.class,0);
496                }
497                public LiTagCloseContext liTagClose() {
498                        return getRuleContext(LiTagCloseContext.class,0);
499                }
500                public TrTagCloseContext trTagClose() {
501                        return getRuleContext(TrTagCloseContext.class,0);
502                }
503                public TdTagCloseContext tdTagClose() {
504                        return getRuleContext(TdTagCloseContext.class,0);
505                }
506                public ThTagCloseContext thTagClose() {
507                        return getRuleContext(ThTagCloseContext.class,0);
508                }
509                public BodyTagCloseContext bodyTagClose() {
510                        return getRuleContext(BodyTagCloseContext.class,0);
511                }
512                public ColgroupTagCloseContext colgroupTagClose() {
513                        return getRuleContext(ColgroupTagCloseContext.class,0);
514                }
515                public DdTagCloseContext ddTagClose() {
516                        return getRuleContext(DdTagCloseContext.class,0);
517                }
518                public DtTagCloseContext dtTagClose() {
519                        return getRuleContext(DtTagCloseContext.class,0);
520                }
521                public HeadTagCloseContext headTagClose() {
522                        return getRuleContext(HeadTagCloseContext.class,0);
523                }
524                public HtmlTagCloseContext htmlTagClose() {
525                        return getRuleContext(HtmlTagCloseContext.class,0);
526                }
527                public OptionTagCloseContext optionTagClose() {
528                        return getRuleContext(OptionTagCloseContext.class,0);
529                }
530                public TbodyTagCloseContext tbodyTagClose() {
531                        return getRuleContext(TbodyTagCloseContext.class,0);
532                }
533                public TheadTagCloseContext theadTagClose() {
534                        return getRuleContext(TheadTagCloseContext.class,0);
535                }
536                public TfootTagCloseContext tfootTagClose() {
537                        return getRuleContext(TfootTagCloseContext.class,0);
538                }
539                public HtmlElementContext(ParserRuleContext parent, int invokingState) {
540                        super(parent, invokingState);
541                }
542                @Override public int getRuleIndex() { return RULE_htmlElement; }
543                @Override
544                public void enterRule(ParseTreeListener listener) {
545                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this);
546                }
547                @Override
548                public void exitRule(ParseTreeListener listener) {
549                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this);
550                }
551                @Override
552                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
553                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this);
554                        else return visitor.visitChildren(this);
555                }
556        }
557
558        public final HtmlElementContext htmlElement() throws RecognitionException {
559                HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
560                enterRule(_localctx, 2, RULE_htmlElement);
561                try {
562                        setState(227);
563                        _errHandler.sync(this);
564                        switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
565                        case 1:
566                                enterOuterAlt(_localctx, 1);
567                                {
568                                setState(180);
569                                htmlTag();
570                                }
571                                break;
572                        case 2:
573                                enterOuterAlt(_localctx, 2);
574                                {
575                                setState(181);
576                                singletonElement();
577                                }
578                                break;
579                        case 3:
580                                enterOuterAlt(_localctx, 3);
581                                {
582                                setState(182);
583                                paragraph();
584                                }
585                                break;
586                        case 4:
587                                enterOuterAlt(_localctx, 4);
588                                {
589                                setState(183);
590                                li();
591                                }
592                                break;
593                        case 5:
594                                enterOuterAlt(_localctx, 5);
595                                {
596                                setState(184);
597                                tr();
598                                }
599                                break;
600                        case 6:
601                                enterOuterAlt(_localctx, 6);
602                                {
603                                setState(185);
604                                td();
605                                }
606                                break;
607                        case 7:
608                                enterOuterAlt(_localctx, 7);
609                                {
610                                setState(186);
611                                th();
612                                }
613                                break;
614                        case 8:
615                                enterOuterAlt(_localctx, 8);
616                                {
617                                setState(187);
618                                body();
619                                }
620                                break;
621                        case 9:
622                                enterOuterAlt(_localctx, 9);
623                                {
624                                setState(188);
625                                colgroup();
626                                }
627                                break;
628                        case 10:
629                                enterOuterAlt(_localctx, 10);
630                                {
631                                setState(189);
632                                dd();
633                                }
634                                break;
635                        case 11:
636                                enterOuterAlt(_localctx, 11);
637                                {
638                                setState(190);
639                                dt();
640                                }
641                                break;
642                        case 12:
643                                enterOuterAlt(_localctx, 12);
644                                {
645                                setState(191);
646                                head();
647                                }
648                                break;
649                        case 13:
650                                enterOuterAlt(_localctx, 13);
651                                {
652                                setState(192);
653                                html();
654                                }
655                                break;
656                        case 14:
657                                enterOuterAlt(_localctx, 14);
658                                {
659                                setState(193);
660                                option();
661                                }
662                                break;
663                        case 15:
664                                enterOuterAlt(_localctx, 15);
665                                {
666                                setState(194);
667                                tbody();
668                                }
669                                break;
670                        case 16:
671                                enterOuterAlt(_localctx, 16);
672                                {
673                                setState(195);
674                                thead();
675                                }
676                                break;
677                        case 17:
678                                enterOuterAlt(_localctx, 17);
679                                {
680                                setState(196);
681                                tfoot();
682                                }
683                                break;
684                        case 18:
685                                enterOuterAlt(_localctx, 18);
686                                {
687                                setState(197);
688                                pTagOpen();
689                                }
690                                break;
691                        case 19:
692                                enterOuterAlt(_localctx, 19);
693                                {
694                                setState(198);
695                                liTagOpen();
696                                }
697                                break;
698                        case 20:
699                                enterOuterAlt(_localctx, 20);
700                                {
701                                setState(199);
702                                trTagOpen();
703                                }
704                                break;
705                        case 21:
706                                enterOuterAlt(_localctx, 21);
707                                {
708                                setState(200);
709                                tdTagOpen();
710                                }
711                                break;
712                        case 22:
713                                enterOuterAlt(_localctx, 22);
714                                {
715                                setState(201);
716                                thTagOpen();
717                                }
718                                break;
719                        case 23:
720                                enterOuterAlt(_localctx, 23);
721                                {
722                                setState(202);
723                                bodyTagOpen();
724                                }
725                                break;
726                        case 24:
727                                enterOuterAlt(_localctx, 24);
728                                {
729                                setState(203);
730                                colgroupTagOpen();
731                                }
732                                break;
733                        case 25:
734                                enterOuterAlt(_localctx, 25);
735                                {
736                                setState(204);
737                                ddTagOpen();
738                                }
739                                break;
740                        case 26:
741                                enterOuterAlt(_localctx, 26);
742                                {
743                                setState(205);
744                                dtTagOpen();
745                                }
746                                break;
747                        case 27:
748                                enterOuterAlt(_localctx, 27);
749                                {
750                                setState(206);
751                                headTagOpen();
752                                }
753                                break;
754                        case 28:
755                                enterOuterAlt(_localctx, 28);
756                                {
757                                setState(207);
758                                htmlTagOpen();
759                                }
760                                break;
761                        case 29:
762                                enterOuterAlt(_localctx, 29);
763                                {
764                                setState(208);
765                                optionTagOpen();
766                                }
767                                break;
768                        case 30:
769                                enterOuterAlt(_localctx, 30);
770                                {
771                                setState(209);
772                                tbodyTagOpen();
773                                }
774                                break;
775                        case 31:
776                                enterOuterAlt(_localctx, 31);
777                                {
778                                setState(210);
779                                theadTagOpen();
780                                }
781                                break;
782                        case 32:
783                                enterOuterAlt(_localctx, 32);
784                                {
785                                setState(211);
786                                tfootTagOpen();
787                                }
788                                break;
789                        case 33:
790                                enterOuterAlt(_localctx, 33);
791                                {
792                                setState(212);
793                                pTagClose();
794                                }
795                                break;
796                        case 34:
797                                enterOuterAlt(_localctx, 34);
798                                {
799                                setState(213);
800                                liTagClose();
801                                }
802                                break;
803                        case 35:
804                                enterOuterAlt(_localctx, 35);
805                                {
806                                setState(214);
807                                trTagClose();
808                                }
809                                break;
810                        case 36:
811                                enterOuterAlt(_localctx, 36);
812                                {
813                                setState(215);
814                                tdTagClose();
815                                }
816                                break;
817                        case 37:
818                                enterOuterAlt(_localctx, 37);
819                                {
820                                setState(216);
821                                thTagClose();
822                                }
823                                break;
824                        case 38:
825                                enterOuterAlt(_localctx, 38);
826                                {
827                                setState(217);
828                                bodyTagClose();
829                                }
830                                break;
831                        case 39:
832                                enterOuterAlt(_localctx, 39);
833                                {
834                                setState(218);
835                                colgroupTagClose();
836                                }
837                                break;
838                        case 40:
839                                enterOuterAlt(_localctx, 40);
840                                {
841                                setState(219);
842                                ddTagClose();
843                                }
844                                break;
845                        case 41:
846                                enterOuterAlt(_localctx, 41);
847                                {
848                                setState(220);
849                                dtTagClose();
850                                }
851                                break;
852                        case 42:
853                                enterOuterAlt(_localctx, 42);
854                                {
855                                setState(221);
856                                headTagClose();
857                                }
858                                break;
859                        case 43:
860                                enterOuterAlt(_localctx, 43);
861                                {
862                                setState(222);
863                                htmlTagClose();
864                                }
865                                break;
866                        case 44:
867                                enterOuterAlt(_localctx, 44);
868                                {
869                                setState(223);
870                                optionTagClose();
871                                }
872                                break;
873                        case 45:
874                                enterOuterAlt(_localctx, 45);
875                                {
876                                setState(224);
877                                tbodyTagClose();
878                                }
879                                break;
880                        case 46:
881                                enterOuterAlt(_localctx, 46);
882                                {
883                                setState(225);
884                                theadTagClose();
885                                }
886                                break;
887                        case 47:
888                                enterOuterAlt(_localctx, 47);
889                                {
890                                setState(226);
891                                tfootTagClose();
892                                }
893                                break;
894                        }
895                }
896                catch (RecognitionException re) {
897                        _localctx.exception = re;
898                        _errHandler.reportError(this, re);
899                        _errHandler.recover(this, re);
900                }
901                finally {
902                        exitRule();
903                }
904                return _localctx;
905        }
906
907        public static class HtmlElementOpenContext extends ParserRuleContext {
908                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
909                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
910                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
911                public List<AttributeContext> attribute() {
912                        return getRuleContexts(AttributeContext.class);
913                }
914                public AttributeContext attribute(int i) {
915                        return getRuleContext(AttributeContext.class,i);
916                }
917                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
918                public TerminalNode NEWLINE(int i) {
919                        return getToken(JavadocParser.NEWLINE, i);
920                }
921                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
922                public TerminalNode LEADING_ASTERISK(int i) {
923                        return getToken(JavadocParser.LEADING_ASTERISK, i);
924                }
925                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
926                public TerminalNode WS(int i) {
927                        return getToken(JavadocParser.WS, i);
928                }
929                public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) {
930                        super(parent, invokingState);
931                }
932                @Override public int getRuleIndex() { return RULE_htmlElementOpen; }
933                @Override
934                public void enterRule(ParseTreeListener listener) {
935                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this);
936                }
937                @Override
938                public void exitRule(ParseTreeListener listener) {
939                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this);
940                }
941                @Override
942                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
943                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this);
944                        else return visitor.visitChildren(this);
945                }
946        }
947
948        public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException {
949                HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState());
950                enterRule(_localctx, 4, RULE_htmlElementOpen);
951                int _la;
952                try {
953                        enterOuterAlt(_localctx, 1);
954                        {
955                        setState(229);
956                        match(OPEN);
957                        setState(230);
958                        match(HTML_TAG_NAME);
959                        setState(237);
960                        _errHandler.sync(this);
961                        _la = _input.LA(1);
962                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
963                                {
964                                setState(235);
965                                _errHandler.sync(this);
966                                switch (_input.LA(1)) {
967                                case HTML_TAG_NAME:
968                                        {
969                                        setState(231);
970                                        attribute();
971                                        }
972                                        break;
973                                case NEWLINE:
974                                        {
975                                        setState(232);
976                                        match(NEWLINE);
977                                        }
978                                        break;
979                                case LEADING_ASTERISK:
980                                        {
981                                        setState(233);
982                                        match(LEADING_ASTERISK);
983                                        }
984                                        break;
985                                case WS:
986                                        {
987                                        setState(234);
988                                        match(WS);
989                                        }
990                                        break;
991                                default:
992                                        throw new NoViableAltException(this);
993                                }
994                                }
995                                setState(239);
996                                _errHandler.sync(this);
997                                _la = _input.LA(1);
998                        }
999                        setState(240);
1000                        match(CLOSE);
1001                        }
1002                }
1003                catch (RecognitionException re) {
1004                        _localctx.exception = re;
1005                        _errHandler.reportError(this, re);
1006                        _errHandler.recover(this, re);
1007                }
1008                finally {
1009                        exitRule();
1010                }
1011                return _localctx;
1012        }
1013
1014        public static class HtmlElementCloseContext extends ParserRuleContext {
1015                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1016                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1017                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
1018                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1019                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1020                public TerminalNode NEWLINE(int i) {
1021                        return getToken(JavadocParser.NEWLINE, i);
1022                }
1023                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1024                public TerminalNode LEADING_ASTERISK(int i) {
1025                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1026                }
1027                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1028                public TerminalNode WS(int i) {
1029                        return getToken(JavadocParser.WS, i);
1030                }
1031                public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) {
1032                        super(parent, invokingState);
1033                }
1034                @Override public int getRuleIndex() { return RULE_htmlElementClose; }
1035                @Override
1036                public void enterRule(ParseTreeListener listener) {
1037                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this);
1038                }
1039                @Override
1040                public void exitRule(ParseTreeListener listener) {
1041                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this);
1042                }
1043                @Override
1044                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1045                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this);
1046                        else return visitor.visitChildren(this);
1047                }
1048        }
1049
1050        public final HtmlElementCloseContext htmlElementClose() throws RecognitionException {
1051                HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState());
1052                enterRule(_localctx, 6, RULE_htmlElementClose);
1053                int _la;
1054                try {
1055                        enterOuterAlt(_localctx, 1);
1056                        {
1057                        setState(242);
1058                        match(OPEN);
1059                        setState(243);
1060                        match(SLASH);
1061                        setState(244);
1062                        match(HTML_TAG_NAME);
1063                        setState(248);
1064                        _errHandler.sync(this);
1065                        _la = _input.LA(1);
1066                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1067                                {
1068                                {
1069                                setState(245);
1070                                _la = _input.LA(1);
1071                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1072                                _errHandler.recoverInline(this);
1073                                }
1074                                else {
1075                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1076                                        _errHandler.reportMatch(this);
1077                                        consume();
1078                                }
1079                                }
1080                                }
1081                                setState(250);
1082                                _errHandler.sync(this);
1083                                _la = _input.LA(1);
1084                        }
1085                        setState(251);
1086                        match(CLOSE);
1087                        }
1088                }
1089                catch (RecognitionException re) {
1090                        _localctx.exception = re;
1091                        _errHandler.reportError(this, re);
1092                        _errHandler.recover(this, re);
1093                }
1094                finally {
1095                        exitRule();
1096                }
1097                return _localctx;
1098        }
1099
1100        public static class AttributeContext extends ParserRuleContext {
1101                public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
1102                public TerminalNode HTML_TAG_NAME(int i) {
1103                        return getToken(JavadocParser.HTML_TAG_NAME, i);
1104                }
1105                public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
1106                public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
1107                public TextContext text() {
1108                        return getRuleContext(TextContext.class,0);
1109                }
1110                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1111                public TerminalNode NEWLINE(int i) {
1112                        return getToken(JavadocParser.NEWLINE, i);
1113                }
1114                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1115                public TerminalNode LEADING_ASTERISK(int i) {
1116                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1117                }
1118                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1119                public TerminalNode WS(int i) {
1120                        return getToken(JavadocParser.WS, i);
1121                }
1122                public AttributeContext(ParserRuleContext parent, int invokingState) {
1123                        super(parent, invokingState);
1124                }
1125                @Override public int getRuleIndex() { return RULE_attribute; }
1126                @Override
1127                public void enterRule(ParseTreeListener listener) {
1128                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this);
1129                }
1130                @Override
1131                public void exitRule(ParseTreeListener listener) {
1132                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this);
1133                }
1134                @Override
1135                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1136                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this);
1137                        else return visitor.visitChildren(this);
1138                }
1139        }
1140
1141        public final AttributeContext attribute() throws RecognitionException {
1142                AttributeContext _localctx = new AttributeContext(_ctx, getState());
1143                enterRule(_localctx, 8, RULE_attribute);
1144                int _la;
1145                try {
1146                        int _alt;
1147                        enterOuterAlt(_localctx, 1);
1148                        {
1149                        setState(253);
1150                        match(HTML_TAG_NAME);
1151                        setState(257);
1152                        _errHandler.sync(this);
1153                        _la = _input.LA(1);
1154                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1155                                {
1156                                {
1157                                setState(254);
1158                                _la = _input.LA(1);
1159                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1160                                _errHandler.recoverInline(this);
1161                                }
1162                                else {
1163                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1164                                        _errHandler.reportMatch(this);
1165                                        consume();
1166                                }
1167                                }
1168                                }
1169                                setState(259);
1170                                _errHandler.sync(this);
1171                                _la = _input.LA(1);
1172                        }
1173                        setState(260);
1174                        match(EQUALS);
1175                        setState(264);
1176                        _errHandler.sync(this);
1177                        _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1178                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1179                                if ( _alt==1 ) {
1180                                        {
1181                                        {
1182                                        setState(261);
1183                                        _la = _input.LA(1);
1184                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1185                                        _errHandler.recoverInline(this);
1186                                        }
1187                                        else {
1188                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1189                                                _errHandler.reportMatch(this);
1190                                                consume();
1191                                        }
1192                                        }
1193                                        } 
1194                                }
1195                                setState(266);
1196                                _errHandler.sync(this);
1197                                _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1198                        }
1199                        setState(270);
1200                        _errHandler.sync(this);
1201                        switch (_input.LA(1)) {
1202                        case ATTR_VALUE:
1203                                {
1204                                setState(267);
1205                                match(ATTR_VALUE);
1206                                }
1207                                break;
1208                        case WS:
1209                        case CHAR:
1210                                {
1211                                setState(268);
1212                                text();
1213                                }
1214                                break;
1215                        case HTML_TAG_NAME:
1216                                {
1217                                setState(269);
1218                                match(HTML_TAG_NAME);
1219                                }
1220                                break;
1221                        default:
1222                                throw new NoViableAltException(this);
1223                        }
1224                        }
1225                }
1226                catch (RecognitionException re) {
1227                        _localctx.exception = re;
1228                        _errHandler.reportError(this, re);
1229                        _errHandler.recover(this, re);
1230                }
1231                finally {
1232                        exitRule();
1233                }
1234                return _localctx;
1235        }
1236
1237        public static class HtmlTagContext extends ParserRuleContext {
1238                public HtmlElementOpenContext htmlElementOpen;
1239                public HtmlElementOpenContext htmlElementOpen() {
1240                        return getRuleContext(HtmlElementOpenContext.class,0);
1241                }
1242                public HtmlElementCloseContext htmlElementClose() {
1243                        return getRuleContext(HtmlElementCloseContext.class,0);
1244                }
1245                public List<HtmlElementContext> htmlElement() {
1246                        return getRuleContexts(HtmlElementContext.class);
1247                }
1248                public HtmlElementContext htmlElement(int i) {
1249                        return getRuleContext(HtmlElementContext.class,i);
1250                }
1251                public List<HtmlCommentContext> htmlComment() {
1252                        return getRuleContexts(HtmlCommentContext.class);
1253                }
1254                public HtmlCommentContext htmlComment(int i) {
1255                        return getRuleContext(HtmlCommentContext.class,i);
1256                }
1257                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1258                public TerminalNode CDATA(int i) {
1259                        return getToken(JavadocParser.CDATA, i);
1260                }
1261                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1262                public TerminalNode NEWLINE(int i) {
1263                        return getToken(JavadocParser.NEWLINE, i);
1264                }
1265                public List<TextContext> text() {
1266                        return getRuleContexts(TextContext.class);
1267                }
1268                public TextContext text(int i) {
1269                        return getRuleContext(TextContext.class,i);
1270                }
1271                public List<JavadocInlineTagContext> javadocInlineTag() {
1272                        return getRuleContexts(JavadocInlineTagContext.class);
1273                }
1274                public JavadocInlineTagContext javadocInlineTag(int i) {
1275                        return getRuleContext(JavadocInlineTagContext.class,i);
1276                }
1277                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1278                public TerminalNode LEADING_ASTERISK(int i) {
1279                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1280                }
1281                public HtmlTagContext(ParserRuleContext parent, int invokingState) {
1282                        super(parent, invokingState);
1283                }
1284                @Override public int getRuleIndex() { return RULE_htmlTag; }
1285                @Override
1286                public void enterRule(ParseTreeListener listener) {
1287                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this);
1288                }
1289                @Override
1290                public void exitRule(ParseTreeListener listener) {
1291                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this);
1292                }
1293                @Override
1294                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1295                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this);
1296                        else return visitor.visitChildren(this);
1297                }
1298        }
1299
1300        public final HtmlTagContext htmlTag() throws RecognitionException {
1301                HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1302                enterRule(_localctx, 10, RULE_htmlTag);
1303                try {
1304                        int _alt;
1305                        setState(304);
1306                        _errHandler.sync(this);
1307                        switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
1308                        case 1:
1309                                enterOuterAlt(_localctx, 1);
1310                                {
1311                                setState(272);
1312                                htmlElementOpen();
1313                                setState(283);
1314                                _errHandler.sync(this);
1315                                _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1316                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1317                                        if ( _alt==1 ) {
1318                                                {
1319                                                setState(281);
1320                                                _errHandler.sync(this);
1321                                                switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1322                                                case 1:
1323                                                        {
1324                                                        setState(273);
1325                                                        htmlElement();
1326                                                        }
1327                                                        break;
1328                                                case 2:
1329                                                        {
1330                                                        {
1331                                                        setState(274);
1332                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1333                                                        setState(275);
1334                                                        match(LEADING_ASTERISK);
1335                                                        }
1336                                                        }
1337                                                        break;
1338                                                case 3:
1339                                                        {
1340                                                        setState(276);
1341                                                        htmlComment();
1342                                                        }
1343                                                        break;
1344                                                case 4:
1345                                                        {
1346                                                        setState(277);
1347                                                        match(CDATA);
1348                                                        }
1349                                                        break;
1350                                                case 5:
1351                                                        {
1352                                                        setState(278);
1353                                                        match(NEWLINE);
1354                                                        }
1355                                                        break;
1356                                                case 6:
1357                                                        {
1358                                                        setState(279);
1359                                                        text();
1360                                                        }
1361                                                        break;
1362                                                case 7:
1363                                                        {
1364                                                        setState(280);
1365                                                        javadocInlineTag();
1366                                                        }
1367                                                        break;
1368                                                }
1369                                                } 
1370                                        }
1371                                        setState(285);
1372                                        _errHandler.sync(this);
1373                                        _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1374                                }
1375                                setState(286);
1376                                htmlElementClose();
1377                                }
1378                                break;
1379                        case 2:
1380                                enterOuterAlt(_localctx, 2);
1381                                {
1382                                setState(288);
1383                                ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen();
1384                                setState(299);
1385                                _errHandler.sync(this);
1386                                _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1387                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1388                                        if ( _alt==1 ) {
1389                                                {
1390                                                setState(297);
1391                                                _errHandler.sync(this);
1392                                                switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
1393                                                case 1:
1394                                                        {
1395                                                        setState(289);
1396                                                        htmlElement();
1397                                                        }
1398                                                        break;
1399                                                case 2:
1400                                                        {
1401                                                        {
1402                                                        setState(290);
1403                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1404                                                        setState(291);
1405                                                        match(LEADING_ASTERISK);
1406                                                        }
1407                                                        }
1408                                                        break;
1409                                                case 3:
1410                                                        {
1411                                                        setState(292);
1412                                                        htmlComment();
1413                                                        }
1414                                                        break;
1415                                                case 4:
1416                                                        {
1417                                                        setState(293);
1418                                                        match(CDATA);
1419                                                        }
1420                                                        break;
1421                                                case 5:
1422                                                        {
1423                                                        setState(294);
1424                                                        match(NEWLINE);
1425                                                        }
1426                                                        break;
1427                                                case 6:
1428                                                        {
1429                                                        setState(295);
1430                                                        text();
1431                                                        }
1432                                                        break;
1433                                                case 7:
1434                                                        {
1435                                                        setState(296);
1436                                                        javadocInlineTag();
1437                                                        }
1438                                                        break;
1439                                                }
1440                                                } 
1441                                        }
1442                                        setState(301);
1443                                        _errHandler.sync(this);
1444                                        _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1445                                }
1446                                notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol()
1447                                                                         , "javadoc.missed.html.close", null);
1448                                }
1449                                break;
1450                        }
1451                }
1452                catch (RecognitionException re) {
1453                        _localctx.exception = re;
1454                        _errHandler.reportError(this, re);
1455                        _errHandler.recover(this, re);
1456                }
1457                finally {
1458                        exitRule();
1459                }
1460                return _localctx;
1461        }
1462
1463        public static class PTagOpenContext extends ParserRuleContext {
1464                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1465                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1466                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1467                public List<AttributeContext> attribute() {
1468                        return getRuleContexts(AttributeContext.class);
1469                }
1470                public AttributeContext attribute(int i) {
1471                        return getRuleContext(AttributeContext.class,i);
1472                }
1473                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1474                public TerminalNode NEWLINE(int i) {
1475                        return getToken(JavadocParser.NEWLINE, i);
1476                }
1477                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1478                public TerminalNode LEADING_ASTERISK(int i) {
1479                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1480                }
1481                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1482                public TerminalNode WS(int i) {
1483                        return getToken(JavadocParser.WS, i);
1484                }
1485                public PTagOpenContext(ParserRuleContext parent, int invokingState) {
1486                        super(parent, invokingState);
1487                }
1488                @Override public int getRuleIndex() { return RULE_pTagOpen; }
1489                @Override
1490                public void enterRule(ParseTreeListener listener) {
1491                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this);
1492                }
1493                @Override
1494                public void exitRule(ParseTreeListener listener) {
1495                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this);
1496                }
1497                @Override
1498                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1499                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this);
1500                        else return visitor.visitChildren(this);
1501                }
1502        }
1503
1504        public final PTagOpenContext pTagOpen() throws RecognitionException {
1505                PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState());
1506                enterRule(_localctx, 12, RULE_pTagOpen);
1507                int _la;
1508                try {
1509                        enterOuterAlt(_localctx, 1);
1510                        {
1511                        setState(306);
1512                        match(OPEN);
1513                        setState(307);
1514                        match(P_HTML_TAG_NAME);
1515                        setState(314);
1516                        _errHandler.sync(this);
1517                        _la = _input.LA(1);
1518                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1519                                {
1520                                setState(312);
1521                                _errHandler.sync(this);
1522                                switch (_input.LA(1)) {
1523                                case HTML_TAG_NAME:
1524                                        {
1525                                        setState(308);
1526                                        attribute();
1527                                        }
1528                                        break;
1529                                case NEWLINE:
1530                                        {
1531                                        setState(309);
1532                                        match(NEWLINE);
1533                                        }
1534                                        break;
1535                                case LEADING_ASTERISK:
1536                                        {
1537                                        setState(310);
1538                                        match(LEADING_ASTERISK);
1539                                        }
1540                                        break;
1541                                case WS:
1542                                        {
1543                                        setState(311);
1544                                        match(WS);
1545                                        }
1546                                        break;
1547                                default:
1548                                        throw new NoViableAltException(this);
1549                                }
1550                                }
1551                                setState(316);
1552                                _errHandler.sync(this);
1553                                _la = _input.LA(1);
1554                        }
1555                        setState(317);
1556                        match(CLOSE);
1557                        }
1558                }
1559                catch (RecognitionException re) {
1560                        _localctx.exception = re;
1561                        _errHandler.reportError(this, re);
1562                        _errHandler.recover(this, re);
1563                }
1564                finally {
1565                        exitRule();
1566                }
1567                return _localctx;
1568        }
1569
1570        public static class PTagCloseContext extends ParserRuleContext {
1571                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1572                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1573                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1574                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1575                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1576                public TerminalNode NEWLINE(int i) {
1577                        return getToken(JavadocParser.NEWLINE, i);
1578                }
1579                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1580                public TerminalNode LEADING_ASTERISK(int i) {
1581                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1582                }
1583                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1584                public TerminalNode WS(int i) {
1585                        return getToken(JavadocParser.WS, i);
1586                }
1587                public PTagCloseContext(ParserRuleContext parent, int invokingState) {
1588                        super(parent, invokingState);
1589                }
1590                @Override public int getRuleIndex() { return RULE_pTagClose; }
1591                @Override
1592                public void enterRule(ParseTreeListener listener) {
1593                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this);
1594                }
1595                @Override
1596                public void exitRule(ParseTreeListener listener) {
1597                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this);
1598                }
1599                @Override
1600                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1601                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this);
1602                        else return visitor.visitChildren(this);
1603                }
1604        }
1605
1606        public final PTagCloseContext pTagClose() throws RecognitionException {
1607                PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState());
1608                enterRule(_localctx, 14, RULE_pTagClose);
1609                int _la;
1610                try {
1611                        enterOuterAlt(_localctx, 1);
1612                        {
1613                        setState(319);
1614                        match(OPEN);
1615                        setState(320);
1616                        match(SLASH);
1617                        setState(321);
1618                        match(P_HTML_TAG_NAME);
1619                        setState(325);
1620                        _errHandler.sync(this);
1621                        _la = _input.LA(1);
1622                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1623                                {
1624                                {
1625                                setState(322);
1626                                _la = _input.LA(1);
1627                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1628                                _errHandler.recoverInline(this);
1629                                }
1630                                else {
1631                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1632                                        _errHandler.reportMatch(this);
1633                                        consume();
1634                                }
1635                                }
1636                                }
1637                                setState(327);
1638                                _errHandler.sync(this);
1639                                _la = _input.LA(1);
1640                        }
1641                        setState(328);
1642                        match(CLOSE);
1643                        }
1644                }
1645                catch (RecognitionException re) {
1646                        _localctx.exception = re;
1647                        _errHandler.reportError(this, re);
1648                        _errHandler.recover(this, re);
1649                }
1650                finally {
1651                        exitRule();
1652                }
1653                return _localctx;
1654        }
1655
1656        public static class ParagraphContext extends ParserRuleContext {
1657                public PTagOpenContext pTagOpen() {
1658                        return getRuleContext(PTagOpenContext.class,0);
1659                }
1660                public PTagCloseContext pTagClose() {
1661                        return getRuleContext(PTagCloseContext.class,0);
1662                }
1663                public List<HtmlTagContext> htmlTag() {
1664                        return getRuleContexts(HtmlTagContext.class);
1665                }
1666                public HtmlTagContext htmlTag(int i) {
1667                        return getRuleContext(HtmlTagContext.class,i);
1668                }
1669                public List<SingletonTagContext> singletonTag() {
1670                        return getRuleContexts(SingletonTagContext.class);
1671                }
1672                public SingletonTagContext singletonTag(int i) {
1673                        return getRuleContext(SingletonTagContext.class,i);
1674                }
1675                public List<LiContext> li() {
1676                        return getRuleContexts(LiContext.class);
1677                }
1678                public LiContext li(int i) {
1679                        return getRuleContext(LiContext.class,i);
1680                }
1681                public List<TrContext> tr() {
1682                        return getRuleContexts(TrContext.class);
1683                }
1684                public TrContext tr(int i) {
1685                        return getRuleContext(TrContext.class,i);
1686                }
1687                public List<TdContext> td() {
1688                        return getRuleContexts(TdContext.class);
1689                }
1690                public TdContext td(int i) {
1691                        return getRuleContext(TdContext.class,i);
1692                }
1693                public List<ThContext> th() {
1694                        return getRuleContexts(ThContext.class);
1695                }
1696                public ThContext th(int i) {
1697                        return getRuleContext(ThContext.class,i);
1698                }
1699                public List<BodyContext> body() {
1700                        return getRuleContexts(BodyContext.class);
1701                }
1702                public BodyContext body(int i) {
1703                        return getRuleContext(BodyContext.class,i);
1704                }
1705                public List<ColgroupContext> colgroup() {
1706                        return getRuleContexts(ColgroupContext.class);
1707                }
1708                public ColgroupContext colgroup(int i) {
1709                        return getRuleContext(ColgroupContext.class,i);
1710                }
1711                public List<DdContext> dd() {
1712                        return getRuleContexts(DdContext.class);
1713                }
1714                public DdContext dd(int i) {
1715                        return getRuleContext(DdContext.class,i);
1716                }
1717                public List<DtContext> dt() {
1718                        return getRuleContexts(DtContext.class);
1719                }
1720                public DtContext dt(int i) {
1721                        return getRuleContext(DtContext.class,i);
1722                }
1723                public List<HeadContext> head() {
1724                        return getRuleContexts(HeadContext.class);
1725                }
1726                public HeadContext head(int i) {
1727                        return getRuleContext(HeadContext.class,i);
1728                }
1729                public List<HtmlContext> html() {
1730                        return getRuleContexts(HtmlContext.class);
1731                }
1732                public HtmlContext html(int i) {
1733                        return getRuleContext(HtmlContext.class,i);
1734                }
1735                public List<OptionContext> option() {
1736                        return getRuleContexts(OptionContext.class);
1737                }
1738                public OptionContext option(int i) {
1739                        return getRuleContext(OptionContext.class,i);
1740                }
1741                public List<TbodyContext> tbody() {
1742                        return getRuleContexts(TbodyContext.class);
1743                }
1744                public TbodyContext tbody(int i) {
1745                        return getRuleContext(TbodyContext.class,i);
1746                }
1747                public List<TheadContext> thead() {
1748                        return getRuleContexts(TheadContext.class);
1749                }
1750                public TheadContext thead(int i) {
1751                        return getRuleContext(TheadContext.class,i);
1752                }
1753                public List<TfootContext> tfoot() {
1754                        return getRuleContexts(TfootContext.class);
1755                }
1756                public TfootContext tfoot(int i) {
1757                        return getRuleContext(TfootContext.class,i);
1758                }
1759                public List<LiTagOpenContext> liTagOpen() {
1760                        return getRuleContexts(LiTagOpenContext.class);
1761                }
1762                public LiTagOpenContext liTagOpen(int i) {
1763                        return getRuleContext(LiTagOpenContext.class,i);
1764                }
1765                public List<TrTagOpenContext> trTagOpen() {
1766                        return getRuleContexts(TrTagOpenContext.class);
1767                }
1768                public TrTagOpenContext trTagOpen(int i) {
1769                        return getRuleContext(TrTagOpenContext.class,i);
1770                }
1771                public List<TdTagOpenContext> tdTagOpen() {
1772                        return getRuleContexts(TdTagOpenContext.class);
1773                }
1774                public TdTagOpenContext tdTagOpen(int i) {
1775                        return getRuleContext(TdTagOpenContext.class,i);
1776                }
1777                public List<ThTagOpenContext> thTagOpen() {
1778                        return getRuleContexts(ThTagOpenContext.class);
1779                }
1780                public ThTagOpenContext thTagOpen(int i) {
1781                        return getRuleContext(ThTagOpenContext.class,i);
1782                }
1783                public List<BodyTagOpenContext> bodyTagOpen() {
1784                        return getRuleContexts(BodyTagOpenContext.class);
1785                }
1786                public BodyTagOpenContext bodyTagOpen(int i) {
1787                        return getRuleContext(BodyTagOpenContext.class,i);
1788                }
1789                public List<ColgroupTagOpenContext> colgroupTagOpen() {
1790                        return getRuleContexts(ColgroupTagOpenContext.class);
1791                }
1792                public ColgroupTagOpenContext colgroupTagOpen(int i) {
1793                        return getRuleContext(ColgroupTagOpenContext.class,i);
1794                }
1795                public List<DdTagOpenContext> ddTagOpen() {
1796                        return getRuleContexts(DdTagOpenContext.class);
1797                }
1798                public DdTagOpenContext ddTagOpen(int i) {
1799                        return getRuleContext(DdTagOpenContext.class,i);
1800                }
1801                public List<DtTagOpenContext> dtTagOpen() {
1802                        return getRuleContexts(DtTagOpenContext.class);
1803                }
1804                public DtTagOpenContext dtTagOpen(int i) {
1805                        return getRuleContext(DtTagOpenContext.class,i);
1806                }
1807                public List<HeadTagOpenContext> headTagOpen() {
1808                        return getRuleContexts(HeadTagOpenContext.class);
1809                }
1810                public HeadTagOpenContext headTagOpen(int i) {
1811                        return getRuleContext(HeadTagOpenContext.class,i);
1812                }
1813                public List<HtmlTagOpenContext> htmlTagOpen() {
1814                        return getRuleContexts(HtmlTagOpenContext.class);
1815                }
1816                public HtmlTagOpenContext htmlTagOpen(int i) {
1817                        return getRuleContext(HtmlTagOpenContext.class,i);
1818                }
1819                public List<OptionTagOpenContext> optionTagOpen() {
1820                        return getRuleContexts(OptionTagOpenContext.class);
1821                }
1822                public OptionTagOpenContext optionTagOpen(int i) {
1823                        return getRuleContext(OptionTagOpenContext.class,i);
1824                }
1825                public List<TbodyTagOpenContext> tbodyTagOpen() {
1826                        return getRuleContexts(TbodyTagOpenContext.class);
1827                }
1828                public TbodyTagOpenContext tbodyTagOpen(int i) {
1829                        return getRuleContext(TbodyTagOpenContext.class,i);
1830                }
1831                public List<TheadTagOpenContext> theadTagOpen() {
1832                        return getRuleContexts(TheadTagOpenContext.class);
1833                }
1834                public TheadTagOpenContext theadTagOpen(int i) {
1835                        return getRuleContext(TheadTagOpenContext.class,i);
1836                }
1837                public List<TfootTagOpenContext> tfootTagOpen() {
1838                        return getRuleContexts(TfootTagOpenContext.class);
1839                }
1840                public TfootTagOpenContext tfootTagOpen(int i) {
1841                        return getRuleContext(TfootTagOpenContext.class,i);
1842                }
1843                public List<HtmlCommentContext> htmlComment() {
1844                        return getRuleContexts(HtmlCommentContext.class);
1845                }
1846                public HtmlCommentContext htmlComment(int i) {
1847                        return getRuleContext(HtmlCommentContext.class,i);
1848                }
1849                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1850                public TerminalNode CDATA(int i) {
1851                        return getToken(JavadocParser.CDATA, i);
1852                }
1853                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1854                public TerminalNode NEWLINE(int i) {
1855                        return getToken(JavadocParser.NEWLINE, i);
1856                }
1857                public List<TextContext> text() {
1858                        return getRuleContexts(TextContext.class);
1859                }
1860                public TextContext text(int i) {
1861                        return getRuleContext(TextContext.class,i);
1862                }
1863                public List<JavadocInlineTagContext> javadocInlineTag() {
1864                        return getRuleContexts(JavadocInlineTagContext.class);
1865                }
1866                public JavadocInlineTagContext javadocInlineTag(int i) {
1867                        return getRuleContext(JavadocInlineTagContext.class,i);
1868                }
1869                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1870                public TerminalNode LEADING_ASTERISK(int i) {
1871                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1872                }
1873                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1874                        super(parent, invokingState);
1875                }
1876                @Override public int getRuleIndex() { return RULE_paragraph; }
1877                @Override
1878                public void enterRule(ParseTreeListener listener) {
1879                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this);
1880                }
1881                @Override
1882                public void exitRule(ParseTreeListener listener) {
1883                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this);
1884                }
1885                @Override
1886                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1887                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this);
1888                        else return visitor.visitChildren(this);
1889                }
1890        }
1891
1892        public final ParagraphContext paragraph() throws RecognitionException {
1893                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1894                enterRule(_localctx, 16, RULE_paragraph);
1895                try {
1896                        int _alt;
1897                        enterOuterAlt(_localctx, 1);
1898                        {
1899                        setState(330);
1900                        pTagOpen();
1901                        setState(370);
1902                        _errHandler.sync(this);
1903                        _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1904                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1905                                if ( _alt==1 ) {
1906                                        {
1907                                        setState(368);
1908                                        _errHandler.sync(this);
1909                                        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
1910                                        case 1:
1911                                                {
1912                                                setState(331);
1913                                                htmlTag();
1914                                                }
1915                                                break;
1916                                        case 2:
1917                                                {
1918                                                setState(332);
1919                                                singletonTag();
1920                                                }
1921                                                break;
1922                                        case 3:
1923                                                {
1924                                                setState(333);
1925                                                li();
1926                                                }
1927                                                break;
1928                                        case 4:
1929                                                {
1930                                                setState(334);
1931                                                tr();
1932                                                }
1933                                                break;
1934                                        case 5:
1935                                                {
1936                                                setState(335);
1937                                                td();
1938                                                }
1939                                                break;
1940                                        case 6:
1941                                                {
1942                                                setState(336);
1943                                                th();
1944                                                }
1945                                                break;
1946                                        case 7:
1947                                                {
1948                                                setState(337);
1949                                                body();
1950                                                }
1951                                                break;
1952                                        case 8:
1953                                                {
1954                                                setState(338);
1955                                                colgroup();
1956                                                }
1957                                                break;
1958                                        case 9:
1959                                                {
1960                                                setState(339);
1961                                                dd();
1962                                                }
1963                                                break;
1964                                        case 10:
1965                                                {
1966                                                setState(340);
1967                                                dt();
1968                                                }
1969                                                break;
1970                                        case 11:
1971                                                {
1972                                                setState(341);
1973                                                head();
1974                                                }
1975                                                break;
1976                                        case 12:
1977                                                {
1978                                                setState(342);
1979                                                html();
1980                                                }
1981                                                break;
1982                                        case 13:
1983                                                {
1984                                                setState(343);
1985                                                option();
1986                                                }
1987                                                break;
1988                                        case 14:
1989                                                {
1990                                                setState(344);
1991                                                tbody();
1992                                                }
1993                                                break;
1994                                        case 15:
1995                                                {
1996                                                setState(345);
1997                                                thead();
1998                                                }
1999                                                break;
2000                                        case 16:
2001                                                {
2002                                                setState(346);
2003                                                tfoot();
2004                                                }
2005                                                break;
2006                                        case 17:
2007                                                {
2008                                                setState(347);
2009                                                liTagOpen();
2010                                                }
2011                                                break;
2012                                        case 18:
2013                                                {
2014                                                setState(348);
2015                                                trTagOpen();
2016                                                }
2017                                                break;
2018                                        case 19:
2019                                                {
2020                                                setState(349);
2021                                                tdTagOpen();
2022                                                }
2023                                                break;
2024                                        case 20:
2025                                                {
2026                                                setState(350);
2027                                                thTagOpen();
2028                                                }
2029                                                break;
2030                                        case 21:
2031                                                {
2032                                                setState(351);
2033                                                bodyTagOpen();
2034                                                }
2035                                                break;
2036                                        case 22:
2037                                                {
2038                                                setState(352);
2039                                                colgroupTagOpen();
2040                                                }
2041                                                break;
2042                                        case 23:
2043                                                {
2044                                                setState(353);
2045                                                ddTagOpen();
2046                                                }
2047                                                break;
2048                                        case 24:
2049                                                {
2050                                                setState(354);
2051                                                dtTagOpen();
2052                                                }
2053                                                break;
2054                                        case 25:
2055                                                {
2056                                                setState(355);
2057                                                headTagOpen();
2058                                                }
2059                                                break;
2060                                        case 26:
2061                                                {
2062                                                setState(356);
2063                                                htmlTagOpen();
2064                                                }
2065                                                break;
2066                                        case 27:
2067                                                {
2068                                                setState(357);
2069                                                optionTagOpen();
2070                                                }
2071                                                break;
2072                                        case 28:
2073                                                {
2074                                                setState(358);
2075                                                tbodyTagOpen();
2076                                                }
2077                                                break;
2078                                        case 29:
2079                                                {
2080                                                setState(359);
2081                                                theadTagOpen();
2082                                                }
2083                                                break;
2084                                        case 30:
2085                                                {
2086                                                setState(360);
2087                                                tfootTagOpen();
2088                                                }
2089                                                break;
2090                                        case 31:
2091                                                {
2092                                                {
2093                                                setState(361);
2094                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2095                                                setState(362);
2096                                                match(LEADING_ASTERISK);
2097                                                }
2098                                                }
2099                                                break;
2100                                        case 32:
2101                                                {
2102                                                setState(363);
2103                                                htmlComment();
2104                                                }
2105                                                break;
2106                                        case 33:
2107                                                {
2108                                                setState(364);
2109                                                match(CDATA);
2110                                                }
2111                                                break;
2112                                        case 34:
2113                                                {
2114                                                setState(365);
2115                                                match(NEWLINE);
2116                                                }
2117                                                break;
2118                                        case 35:
2119                                                {
2120                                                setState(366);
2121                                                text();
2122                                                }
2123                                                break;
2124                                        case 36:
2125                                                {
2126                                                setState(367);
2127                                                javadocInlineTag();
2128                                                }
2129                                                break;
2130                                        }
2131                                        } 
2132                                }
2133                                setState(372);
2134                                _errHandler.sync(this);
2135                                _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
2136                        }
2137                        setState(373);
2138                        pTagClose();
2139                        }
2140                }
2141                catch (RecognitionException re) {
2142                        _localctx.exception = re;
2143                        _errHandler.reportError(this, re);
2144                        _errHandler.recover(this, re);
2145                }
2146                finally {
2147                        exitRule();
2148                }
2149                return _localctx;
2150        }
2151
2152        public static class LiTagOpenContext extends ParserRuleContext {
2153                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2154                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2155                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2156                public List<AttributeContext> attribute() {
2157                        return getRuleContexts(AttributeContext.class);
2158                }
2159                public AttributeContext attribute(int i) {
2160                        return getRuleContext(AttributeContext.class,i);
2161                }
2162                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2163                public TerminalNode NEWLINE(int i) {
2164                        return getToken(JavadocParser.NEWLINE, i);
2165                }
2166                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2167                public TerminalNode LEADING_ASTERISK(int i) {
2168                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2169                }
2170                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2171                public TerminalNode WS(int i) {
2172                        return getToken(JavadocParser.WS, i);
2173                }
2174                public LiTagOpenContext(ParserRuleContext parent, int invokingState) {
2175                        super(parent, invokingState);
2176                }
2177                @Override public int getRuleIndex() { return RULE_liTagOpen; }
2178                @Override
2179                public void enterRule(ParseTreeListener listener) {
2180                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this);
2181                }
2182                @Override
2183                public void exitRule(ParseTreeListener listener) {
2184                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this);
2185                }
2186                @Override
2187                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2188                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this);
2189                        else return visitor.visitChildren(this);
2190                }
2191        }
2192
2193        public final LiTagOpenContext liTagOpen() throws RecognitionException {
2194                LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState());
2195                enterRule(_localctx, 18, RULE_liTagOpen);
2196                int _la;
2197                try {
2198                        enterOuterAlt(_localctx, 1);
2199                        {
2200                        setState(375);
2201                        match(OPEN);
2202                        setState(376);
2203                        match(LI_HTML_TAG_NAME);
2204                        setState(383);
2205                        _errHandler.sync(this);
2206                        _la = _input.LA(1);
2207                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2208                                {
2209                                setState(381);
2210                                _errHandler.sync(this);
2211                                switch (_input.LA(1)) {
2212                                case HTML_TAG_NAME:
2213                                        {
2214                                        setState(377);
2215                                        attribute();
2216                                        }
2217                                        break;
2218                                case NEWLINE:
2219                                        {
2220                                        setState(378);
2221                                        match(NEWLINE);
2222                                        }
2223                                        break;
2224                                case LEADING_ASTERISK:
2225                                        {
2226                                        setState(379);
2227                                        match(LEADING_ASTERISK);
2228                                        }
2229                                        break;
2230                                case WS:
2231                                        {
2232                                        setState(380);
2233                                        match(WS);
2234                                        }
2235                                        break;
2236                                default:
2237                                        throw new NoViableAltException(this);
2238                                }
2239                                }
2240                                setState(385);
2241                                _errHandler.sync(this);
2242                                _la = _input.LA(1);
2243                        }
2244                        setState(386);
2245                        match(CLOSE);
2246                        }
2247                }
2248                catch (RecognitionException re) {
2249                        _localctx.exception = re;
2250                        _errHandler.reportError(this, re);
2251                        _errHandler.recover(this, re);
2252                }
2253                finally {
2254                        exitRule();
2255                }
2256                return _localctx;
2257        }
2258
2259        public static class LiTagCloseContext extends ParserRuleContext {
2260                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2261                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2262                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2263                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2264                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2265                public TerminalNode NEWLINE(int i) {
2266                        return getToken(JavadocParser.NEWLINE, i);
2267                }
2268                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2269                public TerminalNode LEADING_ASTERISK(int i) {
2270                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2271                }
2272                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2273                public TerminalNode WS(int i) {
2274                        return getToken(JavadocParser.WS, i);
2275                }
2276                public LiTagCloseContext(ParserRuleContext parent, int invokingState) {
2277                        super(parent, invokingState);
2278                }
2279                @Override public int getRuleIndex() { return RULE_liTagClose; }
2280                @Override
2281                public void enterRule(ParseTreeListener listener) {
2282                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this);
2283                }
2284                @Override
2285                public void exitRule(ParseTreeListener listener) {
2286                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this);
2287                }
2288                @Override
2289                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2290                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this);
2291                        else return visitor.visitChildren(this);
2292                }
2293        }
2294
2295        public final LiTagCloseContext liTagClose() throws RecognitionException {
2296                LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState());
2297                enterRule(_localctx, 20, RULE_liTagClose);
2298                int _la;
2299                try {
2300                        enterOuterAlt(_localctx, 1);
2301                        {
2302                        setState(388);
2303                        match(OPEN);
2304                        setState(389);
2305                        match(SLASH);
2306                        setState(390);
2307                        match(LI_HTML_TAG_NAME);
2308                        setState(394);
2309                        _errHandler.sync(this);
2310                        _la = _input.LA(1);
2311                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2312                                {
2313                                {
2314                                setState(391);
2315                                _la = _input.LA(1);
2316                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2317                                _errHandler.recoverInline(this);
2318                                }
2319                                else {
2320                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
2321                                        _errHandler.reportMatch(this);
2322                                        consume();
2323                                }
2324                                }
2325                                }
2326                                setState(396);
2327                                _errHandler.sync(this);
2328                                _la = _input.LA(1);
2329                        }
2330                        setState(397);
2331                        match(CLOSE);
2332                        }
2333                }
2334                catch (RecognitionException re) {
2335                        _localctx.exception = re;
2336                        _errHandler.reportError(this, re);
2337                        _errHandler.recover(this, re);
2338                }
2339                finally {
2340                        exitRule();
2341                }
2342                return _localctx;
2343        }
2344
2345        public static class LiContext extends ParserRuleContext {
2346                public LiTagOpenContext liTagOpen() {
2347                        return getRuleContext(LiTagOpenContext.class,0);
2348                }
2349                public LiTagCloseContext liTagClose() {
2350                        return getRuleContext(LiTagCloseContext.class,0);
2351                }
2352                public List<HtmlTagContext> htmlTag() {
2353                        return getRuleContexts(HtmlTagContext.class);
2354                }
2355                public HtmlTagContext htmlTag(int i) {
2356                        return getRuleContext(HtmlTagContext.class,i);
2357                }
2358                public List<SingletonTagContext> singletonTag() {
2359                        return getRuleContexts(SingletonTagContext.class);
2360                }
2361                public SingletonTagContext singletonTag(int i) {
2362                        return getRuleContext(SingletonTagContext.class,i);
2363                }
2364                public List<ParagraphContext> paragraph() {
2365                        return getRuleContexts(ParagraphContext.class);
2366                }
2367                public ParagraphContext paragraph(int i) {
2368                        return getRuleContext(ParagraphContext.class,i);
2369                }
2370                public List<TrContext> tr() {
2371                        return getRuleContexts(TrContext.class);
2372                }
2373                public TrContext tr(int i) {
2374                        return getRuleContext(TrContext.class,i);
2375                }
2376                public List<TdContext> td() {
2377                        return getRuleContexts(TdContext.class);
2378                }
2379                public TdContext td(int i) {
2380                        return getRuleContext(TdContext.class,i);
2381                }
2382                public List<ThContext> th() {
2383                        return getRuleContexts(ThContext.class);
2384                }
2385                public ThContext th(int i) {
2386                        return getRuleContext(ThContext.class,i);
2387                }
2388                public List<BodyContext> body() {
2389                        return getRuleContexts(BodyContext.class);
2390                }
2391                public BodyContext body(int i) {
2392                        return getRuleContext(BodyContext.class,i);
2393                }
2394                public List<ColgroupContext> colgroup() {
2395                        return getRuleContexts(ColgroupContext.class);
2396                }
2397                public ColgroupContext colgroup(int i) {
2398                        return getRuleContext(ColgroupContext.class,i);
2399                }
2400                public List<DdContext> dd() {
2401                        return getRuleContexts(DdContext.class);
2402                }
2403                public DdContext dd(int i) {
2404                        return getRuleContext(DdContext.class,i);
2405                }
2406                public List<DtContext> dt() {
2407                        return getRuleContexts(DtContext.class);
2408                }
2409                public DtContext dt(int i) {
2410                        return getRuleContext(DtContext.class,i);
2411                }
2412                public List<HeadContext> head() {
2413                        return getRuleContexts(HeadContext.class);
2414                }
2415                public HeadContext head(int i) {
2416                        return getRuleContext(HeadContext.class,i);
2417                }
2418                public List<HtmlContext> html() {
2419                        return getRuleContexts(HtmlContext.class);
2420                }
2421                public HtmlContext html(int i) {
2422                        return getRuleContext(HtmlContext.class,i);
2423                }
2424                public List<OptionContext> option() {
2425                        return getRuleContexts(OptionContext.class);
2426                }
2427                public OptionContext option(int i) {
2428                        return getRuleContext(OptionContext.class,i);
2429                }
2430                public List<TbodyContext> tbody() {
2431                        return getRuleContexts(TbodyContext.class);
2432                }
2433                public TbodyContext tbody(int i) {
2434                        return getRuleContext(TbodyContext.class,i);
2435                }
2436                public List<TheadContext> thead() {
2437                        return getRuleContexts(TheadContext.class);
2438                }
2439                public TheadContext thead(int i) {
2440                        return getRuleContext(TheadContext.class,i);
2441                }
2442                public List<TfootContext> tfoot() {
2443                        return getRuleContexts(TfootContext.class);
2444                }
2445                public TfootContext tfoot(int i) {
2446                        return getRuleContext(TfootContext.class,i);
2447                }
2448                public List<PTagOpenContext> pTagOpen() {
2449                        return getRuleContexts(PTagOpenContext.class);
2450                }
2451                public PTagOpenContext pTagOpen(int i) {
2452                        return getRuleContext(PTagOpenContext.class,i);
2453                }
2454                public List<TrTagOpenContext> trTagOpen() {
2455                        return getRuleContexts(TrTagOpenContext.class);
2456                }
2457                public TrTagOpenContext trTagOpen(int i) {
2458                        return getRuleContext(TrTagOpenContext.class,i);
2459                }
2460                public List<TdTagOpenContext> tdTagOpen() {
2461                        return getRuleContexts(TdTagOpenContext.class);
2462                }
2463                public TdTagOpenContext tdTagOpen(int i) {
2464                        return getRuleContext(TdTagOpenContext.class,i);
2465                }
2466                public List<ThTagOpenContext> thTagOpen() {
2467                        return getRuleContexts(ThTagOpenContext.class);
2468                }
2469                public ThTagOpenContext thTagOpen(int i) {
2470                        return getRuleContext(ThTagOpenContext.class,i);
2471                }
2472                public List<BodyTagOpenContext> bodyTagOpen() {
2473                        return getRuleContexts(BodyTagOpenContext.class);
2474                }
2475                public BodyTagOpenContext bodyTagOpen(int i) {
2476                        return getRuleContext(BodyTagOpenContext.class,i);
2477                }
2478                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2479                        return getRuleContexts(ColgroupTagOpenContext.class);
2480                }
2481                public ColgroupTagOpenContext colgroupTagOpen(int i) {
2482                        return getRuleContext(ColgroupTagOpenContext.class,i);
2483                }
2484                public List<DdTagOpenContext> ddTagOpen() {
2485                        return getRuleContexts(DdTagOpenContext.class);
2486                }
2487                public DdTagOpenContext ddTagOpen(int i) {
2488                        return getRuleContext(DdTagOpenContext.class,i);
2489                }
2490                public List<DtTagOpenContext> dtTagOpen() {
2491                        return getRuleContexts(DtTagOpenContext.class);
2492                }
2493                public DtTagOpenContext dtTagOpen(int i) {
2494                        return getRuleContext(DtTagOpenContext.class,i);
2495                }
2496                public List<HeadTagOpenContext> headTagOpen() {
2497                        return getRuleContexts(HeadTagOpenContext.class);
2498                }
2499                public HeadTagOpenContext headTagOpen(int i) {
2500                        return getRuleContext(HeadTagOpenContext.class,i);
2501                }
2502                public List<HtmlTagOpenContext> htmlTagOpen() {
2503                        return getRuleContexts(HtmlTagOpenContext.class);
2504                }
2505                public HtmlTagOpenContext htmlTagOpen(int i) {
2506                        return getRuleContext(HtmlTagOpenContext.class,i);
2507                }
2508                public List<OptionTagOpenContext> optionTagOpen() {
2509                        return getRuleContexts(OptionTagOpenContext.class);
2510                }
2511                public OptionTagOpenContext optionTagOpen(int i) {
2512                        return getRuleContext(OptionTagOpenContext.class,i);
2513                }
2514                public List<TbodyTagOpenContext> tbodyTagOpen() {
2515                        return getRuleContexts(TbodyTagOpenContext.class);
2516                }
2517                public TbodyTagOpenContext tbodyTagOpen(int i) {
2518                        return getRuleContext(TbodyTagOpenContext.class,i);
2519                }
2520                public List<TheadTagOpenContext> theadTagOpen() {
2521                        return getRuleContexts(TheadTagOpenContext.class);
2522                }
2523                public TheadTagOpenContext theadTagOpen(int i) {
2524                        return getRuleContext(TheadTagOpenContext.class,i);
2525                }
2526                public List<TfootTagOpenContext> tfootTagOpen() {
2527                        return getRuleContexts(TfootTagOpenContext.class);
2528                }
2529                public TfootTagOpenContext tfootTagOpen(int i) {
2530                        return getRuleContext(TfootTagOpenContext.class,i);
2531                }
2532                public List<HtmlCommentContext> htmlComment() {
2533                        return getRuleContexts(HtmlCommentContext.class);
2534                }
2535                public HtmlCommentContext htmlComment(int i) {
2536                        return getRuleContext(HtmlCommentContext.class,i);
2537                }
2538                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2539                public TerminalNode CDATA(int i) {
2540                        return getToken(JavadocParser.CDATA, i);
2541                }
2542                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2543                public TerminalNode NEWLINE(int i) {
2544                        return getToken(JavadocParser.NEWLINE, i);
2545                }
2546                public List<TextContext> text() {
2547                        return getRuleContexts(TextContext.class);
2548                }
2549                public TextContext text(int i) {
2550                        return getRuleContext(TextContext.class,i);
2551                }
2552                public List<JavadocInlineTagContext> javadocInlineTag() {
2553                        return getRuleContexts(JavadocInlineTagContext.class);
2554                }
2555                public JavadocInlineTagContext javadocInlineTag(int i) {
2556                        return getRuleContext(JavadocInlineTagContext.class,i);
2557                }
2558                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2559                public TerminalNode LEADING_ASTERISK(int i) {
2560                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2561                }
2562                public LiContext(ParserRuleContext parent, int invokingState) {
2563                        super(parent, invokingState);
2564                }
2565                @Override public int getRuleIndex() { return RULE_li; }
2566                @Override
2567                public void enterRule(ParseTreeListener listener) {
2568                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this);
2569                }
2570                @Override
2571                public void exitRule(ParseTreeListener listener) {
2572                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this);
2573                }
2574                @Override
2575                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2576                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this);
2577                        else return visitor.visitChildren(this);
2578                }
2579        }
2580
2581        public final LiContext li() throws RecognitionException {
2582                LiContext _localctx = new LiContext(_ctx, getState());
2583                enterRule(_localctx, 22, RULE_li);
2584                try {
2585                        int _alt;
2586                        enterOuterAlt(_localctx, 1);
2587                        {
2588                        setState(399);
2589                        liTagOpen();
2590                        setState(439);
2591                        _errHandler.sync(this);
2592                        _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2593                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2594                                if ( _alt==1 ) {
2595                                        {
2596                                        setState(437);
2597                                        _errHandler.sync(this);
2598                                        switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
2599                                        case 1:
2600                                                {
2601                                                setState(400);
2602                                                htmlTag();
2603                                                }
2604                                                break;
2605                                        case 2:
2606                                                {
2607                                                setState(401);
2608                                                singletonTag();
2609                                                }
2610                                                break;
2611                                        case 3:
2612                                                {
2613                                                setState(402);
2614                                                paragraph();
2615                                                }
2616                                                break;
2617                                        case 4:
2618                                                {
2619                                                setState(403);
2620                                                tr();
2621                                                }
2622                                                break;
2623                                        case 5:
2624                                                {
2625                                                setState(404);
2626                                                td();
2627                                                }
2628                                                break;
2629                                        case 6:
2630                                                {
2631                                                setState(405);
2632                                                th();
2633                                                }
2634                                                break;
2635                                        case 7:
2636                                                {
2637                                                setState(406);
2638                                                body();
2639                                                }
2640                                                break;
2641                                        case 8:
2642                                                {
2643                                                setState(407);
2644                                                colgroup();
2645                                                }
2646                                                break;
2647                                        case 9:
2648                                                {
2649                                                setState(408);
2650                                                dd();
2651                                                }
2652                                                break;
2653                                        case 10:
2654                                                {
2655                                                setState(409);
2656                                                dt();
2657                                                }
2658                                                break;
2659                                        case 11:
2660                                                {
2661                                                setState(410);
2662                                                head();
2663                                                }
2664                                                break;
2665                                        case 12:
2666                                                {
2667                                                setState(411);
2668                                                html();
2669                                                }
2670                                                break;
2671                                        case 13:
2672                                                {
2673                                                setState(412);
2674                                                option();
2675                                                }
2676                                                break;
2677                                        case 14:
2678                                                {
2679                                                setState(413);
2680                                                tbody();
2681                                                }
2682                                                break;
2683                                        case 15:
2684                                                {
2685                                                setState(414);
2686                                                thead();
2687                                                }
2688                                                break;
2689                                        case 16:
2690                                                {
2691                                                setState(415);
2692                                                tfoot();
2693                                                }
2694                                                break;
2695                                        case 17:
2696                                                {
2697                                                setState(416);
2698                                                pTagOpen();
2699                                                }
2700                                                break;
2701                                        case 18:
2702                                                {
2703                                                setState(417);
2704                                                trTagOpen();
2705                                                }
2706                                                break;
2707                                        case 19:
2708                                                {
2709                                                setState(418);
2710                                                tdTagOpen();
2711                                                }
2712                                                break;
2713                                        case 20:
2714                                                {
2715                                                setState(419);
2716                                                thTagOpen();
2717                                                }
2718                                                break;
2719                                        case 21:
2720                                                {
2721                                                setState(420);
2722                                                bodyTagOpen();
2723                                                }
2724                                                break;
2725                                        case 22:
2726                                                {
2727                                                setState(421);
2728                                                colgroupTagOpen();
2729                                                }
2730                                                break;
2731                                        case 23:
2732                                                {
2733                                                setState(422);
2734                                                ddTagOpen();
2735                                                }
2736                                                break;
2737                                        case 24:
2738                                                {
2739                                                setState(423);
2740                                                dtTagOpen();
2741                                                }
2742                                                break;
2743                                        case 25:
2744                                                {
2745                                                setState(424);
2746                                                headTagOpen();
2747                                                }
2748                                                break;
2749                                        case 26:
2750                                                {
2751                                                setState(425);
2752                                                htmlTagOpen();
2753                                                }
2754                                                break;
2755                                        case 27:
2756                                                {
2757                                                setState(426);
2758                                                optionTagOpen();
2759                                                }
2760                                                break;
2761                                        case 28:
2762                                                {
2763                                                setState(427);
2764                                                tbodyTagOpen();
2765                                                }
2766                                                break;
2767                                        case 29:
2768                                                {
2769                                                setState(428);
2770                                                theadTagOpen();
2771                                                }
2772                                                break;
2773                                        case 30:
2774                                                {
2775                                                setState(429);
2776                                                tfootTagOpen();
2777                                                }
2778                                                break;
2779                                        case 31:
2780                                                {
2781                                                {
2782                                                setState(430);
2783                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2784                                                setState(431);
2785                                                match(LEADING_ASTERISK);
2786                                                }
2787                                                }
2788                                                break;
2789                                        case 32:
2790                                                {
2791                                                setState(432);
2792                                                htmlComment();
2793                                                }
2794                                                break;
2795                                        case 33:
2796                                                {
2797                                                setState(433);
2798                                                match(CDATA);
2799                                                }
2800                                                break;
2801                                        case 34:
2802                                                {
2803                                                setState(434);
2804                                                match(NEWLINE);
2805                                                }
2806                                                break;
2807                                        case 35:
2808                                                {
2809                                                setState(435);
2810                                                text();
2811                                                }
2812                                                break;
2813                                        case 36:
2814                                                {
2815                                                setState(436);
2816                                                javadocInlineTag();
2817                                                }
2818                                                break;
2819                                        }
2820                                        } 
2821                                }
2822                                setState(441);
2823                                _errHandler.sync(this);
2824                                _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2825                        }
2826                        setState(442);
2827                        liTagClose();
2828                        }
2829                }
2830                catch (RecognitionException re) {
2831                        _localctx.exception = re;
2832                        _errHandler.reportError(this, re);
2833                        _errHandler.recover(this, re);
2834                }
2835                finally {
2836                        exitRule();
2837                }
2838                return _localctx;
2839        }
2840
2841        public static class TrTagOpenContext extends ParserRuleContext {
2842                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2843                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2844                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2845                public List<AttributeContext> attribute() {
2846                        return getRuleContexts(AttributeContext.class);
2847                }
2848                public AttributeContext attribute(int i) {
2849                        return getRuleContext(AttributeContext.class,i);
2850                }
2851                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2852                public TerminalNode NEWLINE(int i) {
2853                        return getToken(JavadocParser.NEWLINE, i);
2854                }
2855                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2856                public TerminalNode LEADING_ASTERISK(int i) {
2857                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2858                }
2859                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2860                public TerminalNode WS(int i) {
2861                        return getToken(JavadocParser.WS, i);
2862                }
2863                public TrTagOpenContext(ParserRuleContext parent, int invokingState) {
2864                        super(parent, invokingState);
2865                }
2866                @Override public int getRuleIndex() { return RULE_trTagOpen; }
2867                @Override
2868                public void enterRule(ParseTreeListener listener) {
2869                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this);
2870                }
2871                @Override
2872                public void exitRule(ParseTreeListener listener) {
2873                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this);
2874                }
2875                @Override
2876                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2877                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this);
2878                        else return visitor.visitChildren(this);
2879                }
2880        }
2881
2882        public final TrTagOpenContext trTagOpen() throws RecognitionException {
2883                TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState());
2884                enterRule(_localctx, 24, RULE_trTagOpen);
2885                int _la;
2886                try {
2887                        enterOuterAlt(_localctx, 1);
2888                        {
2889                        setState(444);
2890                        match(OPEN);
2891                        setState(445);
2892                        match(TR_HTML_TAG_NAME);
2893                        setState(452);
2894                        _errHandler.sync(this);
2895                        _la = _input.LA(1);
2896                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2897                                {
2898                                setState(450);
2899                                _errHandler.sync(this);
2900                                switch (_input.LA(1)) {
2901                                case HTML_TAG_NAME:
2902                                        {
2903                                        setState(446);
2904                                        attribute();
2905                                        }
2906                                        break;
2907                                case NEWLINE:
2908                                        {
2909                                        setState(447);
2910                                        match(NEWLINE);
2911                                        }
2912                                        break;
2913                                case LEADING_ASTERISK:
2914                                        {
2915                                        setState(448);
2916                                        match(LEADING_ASTERISK);
2917                                        }
2918                                        break;
2919                                case WS:
2920                                        {
2921                                        setState(449);
2922                                        match(WS);
2923                                        }
2924                                        break;
2925                                default:
2926                                        throw new NoViableAltException(this);
2927                                }
2928                                }
2929                                setState(454);
2930                                _errHandler.sync(this);
2931                                _la = _input.LA(1);
2932                        }
2933                        setState(455);
2934                        match(CLOSE);
2935                        }
2936                }
2937                catch (RecognitionException re) {
2938                        _localctx.exception = re;
2939                        _errHandler.reportError(this, re);
2940                        _errHandler.recover(this, re);
2941                }
2942                finally {
2943                        exitRule();
2944                }
2945                return _localctx;
2946        }
2947
2948        public static class TrTagCloseContext extends ParserRuleContext {
2949                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2950                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2951                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2952                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2953                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2954                public TerminalNode NEWLINE(int i) {
2955                        return getToken(JavadocParser.NEWLINE, i);
2956                }
2957                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2958                public TerminalNode LEADING_ASTERISK(int i) {
2959                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2960                }
2961                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2962                public TerminalNode WS(int i) {
2963                        return getToken(JavadocParser.WS, i);
2964                }
2965                public TrTagCloseContext(ParserRuleContext parent, int invokingState) {
2966                        super(parent, invokingState);
2967                }
2968                @Override public int getRuleIndex() { return RULE_trTagClose; }
2969                @Override
2970                public void enterRule(ParseTreeListener listener) {
2971                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this);
2972                }
2973                @Override
2974                public void exitRule(ParseTreeListener listener) {
2975                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this);
2976                }
2977                @Override
2978                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2979                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this);
2980                        else return visitor.visitChildren(this);
2981                }
2982        }
2983
2984        public final TrTagCloseContext trTagClose() throws RecognitionException {
2985                TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState());
2986                enterRule(_localctx, 26, RULE_trTagClose);
2987                int _la;
2988                try {
2989                        enterOuterAlt(_localctx, 1);
2990                        {
2991                        setState(457);
2992                        match(OPEN);
2993                        setState(458);
2994                        match(SLASH);
2995                        setState(459);
2996                        match(TR_HTML_TAG_NAME);
2997                        setState(463);
2998                        _errHandler.sync(this);
2999                        _la = _input.LA(1);
3000                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3001                                {
3002                                {
3003                                setState(460);
3004                                _la = _input.LA(1);
3005                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3006                                _errHandler.recoverInline(this);
3007                                }
3008                                else {
3009                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
3010                                        _errHandler.reportMatch(this);
3011                                        consume();
3012                                }
3013                                }
3014                                }
3015                                setState(465);
3016                                _errHandler.sync(this);
3017                                _la = _input.LA(1);
3018                        }
3019                        setState(466);
3020                        match(CLOSE);
3021                        }
3022                }
3023                catch (RecognitionException re) {
3024                        _localctx.exception = re;
3025                        _errHandler.reportError(this, re);
3026                        _errHandler.recover(this, re);
3027                }
3028                finally {
3029                        exitRule();
3030                }
3031                return _localctx;
3032        }
3033
3034        public static class TrContext extends ParserRuleContext {
3035                public TrTagOpenContext trTagOpen() {
3036                        return getRuleContext(TrTagOpenContext.class,0);
3037                }
3038                public TrTagCloseContext trTagClose() {
3039                        return getRuleContext(TrTagCloseContext.class,0);
3040                }
3041                public List<HtmlTagContext> htmlTag() {
3042                        return getRuleContexts(HtmlTagContext.class);
3043                }
3044                public HtmlTagContext htmlTag(int i) {
3045                        return getRuleContext(HtmlTagContext.class,i);
3046                }
3047                public List<SingletonTagContext> singletonTag() {
3048                        return getRuleContexts(SingletonTagContext.class);
3049                }
3050                public SingletonTagContext singletonTag(int i) {
3051                        return getRuleContext(SingletonTagContext.class,i);
3052                }
3053                public List<ParagraphContext> paragraph() {
3054                        return getRuleContexts(ParagraphContext.class);
3055                }
3056                public ParagraphContext paragraph(int i) {
3057                        return getRuleContext(ParagraphContext.class,i);
3058                }
3059                public List<LiContext> li() {
3060                        return getRuleContexts(LiContext.class);
3061                }
3062                public LiContext li(int i) {
3063                        return getRuleContext(LiContext.class,i);
3064                }
3065                public List<TdContext> td() {
3066                        return getRuleContexts(TdContext.class);
3067                }
3068                public TdContext td(int i) {
3069                        return getRuleContext(TdContext.class,i);
3070                }
3071                public List<ThContext> th() {
3072                        return getRuleContexts(ThContext.class);
3073                }
3074                public ThContext th(int i) {
3075                        return getRuleContext(ThContext.class,i);
3076                }
3077                public List<BodyContext> body() {
3078                        return getRuleContexts(BodyContext.class);
3079                }
3080                public BodyContext body(int i) {
3081                        return getRuleContext(BodyContext.class,i);
3082                }
3083                public List<ColgroupContext> colgroup() {
3084                        return getRuleContexts(ColgroupContext.class);
3085                }
3086                public ColgroupContext colgroup(int i) {
3087                        return getRuleContext(ColgroupContext.class,i);
3088                }
3089                public List<DdContext> dd() {
3090                        return getRuleContexts(DdContext.class);
3091                }
3092                public DdContext dd(int i) {
3093                        return getRuleContext(DdContext.class,i);
3094                }
3095                public List<DtContext> dt() {
3096                        return getRuleContexts(DtContext.class);
3097                }
3098                public DtContext dt(int i) {
3099                        return getRuleContext(DtContext.class,i);
3100                }
3101                public List<HeadContext> head() {
3102                        return getRuleContexts(HeadContext.class);
3103                }
3104                public HeadContext head(int i) {
3105                        return getRuleContext(HeadContext.class,i);
3106                }
3107                public List<HtmlContext> html() {
3108                        return getRuleContexts(HtmlContext.class);
3109                }
3110                public HtmlContext html(int i) {
3111                        return getRuleContext(HtmlContext.class,i);
3112                }
3113                public List<OptionContext> option() {
3114                        return getRuleContexts(OptionContext.class);
3115                }
3116                public OptionContext option(int i) {
3117                        return getRuleContext(OptionContext.class,i);
3118                }
3119                public List<TbodyContext> tbody() {
3120                        return getRuleContexts(TbodyContext.class);
3121                }
3122                public TbodyContext tbody(int i) {
3123                        return getRuleContext(TbodyContext.class,i);
3124                }
3125                public List<TheadContext> thead() {
3126                        return getRuleContexts(TheadContext.class);
3127                }
3128                public TheadContext thead(int i) {
3129                        return getRuleContext(TheadContext.class,i);
3130                }
3131                public List<TfootContext> tfoot() {
3132                        return getRuleContexts(TfootContext.class);
3133                }
3134                public TfootContext tfoot(int i) {
3135                        return getRuleContext(TfootContext.class,i);
3136                }
3137                public List<PTagOpenContext> pTagOpen() {
3138                        return getRuleContexts(PTagOpenContext.class);
3139                }
3140                public PTagOpenContext pTagOpen(int i) {
3141                        return getRuleContext(PTagOpenContext.class,i);
3142                }
3143                public List<LiTagOpenContext> liTagOpen() {
3144                        return getRuleContexts(LiTagOpenContext.class);
3145                }
3146                public LiTagOpenContext liTagOpen(int i) {
3147                        return getRuleContext(LiTagOpenContext.class,i);
3148                }
3149                public List<TdTagOpenContext> tdTagOpen() {
3150                        return getRuleContexts(TdTagOpenContext.class);
3151                }
3152                public TdTagOpenContext tdTagOpen(int i) {
3153                        return getRuleContext(TdTagOpenContext.class,i);
3154                }
3155                public List<ThTagOpenContext> thTagOpen() {
3156                        return getRuleContexts(ThTagOpenContext.class);
3157                }
3158                public ThTagOpenContext thTagOpen(int i) {
3159                        return getRuleContext(ThTagOpenContext.class,i);
3160                }
3161                public List<BodyTagOpenContext> bodyTagOpen() {
3162                        return getRuleContexts(BodyTagOpenContext.class);
3163                }
3164                public BodyTagOpenContext bodyTagOpen(int i) {
3165                        return getRuleContext(BodyTagOpenContext.class,i);
3166                }
3167                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3168                        return getRuleContexts(ColgroupTagOpenContext.class);
3169                }
3170                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3171                        return getRuleContext(ColgroupTagOpenContext.class,i);
3172                }
3173                public List<DdTagOpenContext> ddTagOpen() {
3174                        return getRuleContexts(DdTagOpenContext.class);
3175                }
3176                public DdTagOpenContext ddTagOpen(int i) {
3177                        return getRuleContext(DdTagOpenContext.class,i);
3178                }
3179                public List<DtTagOpenContext> dtTagOpen() {
3180                        return getRuleContexts(DtTagOpenContext.class);
3181                }
3182                public DtTagOpenContext dtTagOpen(int i) {
3183                        return getRuleContext(DtTagOpenContext.class,i);
3184                }
3185                public List<HeadTagOpenContext> headTagOpen() {
3186                        return getRuleContexts(HeadTagOpenContext.class);
3187                }
3188                public HeadTagOpenContext headTagOpen(int i) {
3189                        return getRuleContext(HeadTagOpenContext.class,i);
3190                }
3191                public List<HtmlTagOpenContext> htmlTagOpen() {
3192                        return getRuleContexts(HtmlTagOpenContext.class);
3193                }
3194                public HtmlTagOpenContext htmlTagOpen(int i) {
3195                        return getRuleContext(HtmlTagOpenContext.class,i);
3196                }
3197                public List<OptionTagOpenContext> optionTagOpen() {
3198                        return getRuleContexts(OptionTagOpenContext.class);
3199                }
3200                public OptionTagOpenContext optionTagOpen(int i) {
3201                        return getRuleContext(OptionTagOpenContext.class,i);
3202                }
3203                public List<TbodyTagOpenContext> tbodyTagOpen() {
3204                        return getRuleContexts(TbodyTagOpenContext.class);
3205                }
3206                public TbodyTagOpenContext tbodyTagOpen(int i) {
3207                        return getRuleContext(TbodyTagOpenContext.class,i);
3208                }
3209                public List<TheadTagOpenContext> theadTagOpen() {
3210                        return getRuleContexts(TheadTagOpenContext.class);
3211                }
3212                public TheadTagOpenContext theadTagOpen(int i) {
3213                        return getRuleContext(TheadTagOpenContext.class,i);
3214                }
3215                public List<TfootTagOpenContext> tfootTagOpen() {
3216                        return getRuleContexts(TfootTagOpenContext.class);
3217                }
3218                public TfootTagOpenContext tfootTagOpen(int i) {
3219                        return getRuleContext(TfootTagOpenContext.class,i);
3220                }
3221                public List<HtmlCommentContext> htmlComment() {
3222                        return getRuleContexts(HtmlCommentContext.class);
3223                }
3224                public HtmlCommentContext htmlComment(int i) {
3225                        return getRuleContext(HtmlCommentContext.class,i);
3226                }
3227                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3228                public TerminalNode CDATA(int i) {
3229                        return getToken(JavadocParser.CDATA, i);
3230                }
3231                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3232                public TerminalNode NEWLINE(int i) {
3233                        return getToken(JavadocParser.NEWLINE, i);
3234                }
3235                public List<TextContext> text() {
3236                        return getRuleContexts(TextContext.class);
3237                }
3238                public TextContext text(int i) {
3239                        return getRuleContext(TextContext.class,i);
3240                }
3241                public List<JavadocInlineTagContext> javadocInlineTag() {
3242                        return getRuleContexts(JavadocInlineTagContext.class);
3243                }
3244                public JavadocInlineTagContext javadocInlineTag(int i) {
3245                        return getRuleContext(JavadocInlineTagContext.class,i);
3246                }
3247                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3248                public TerminalNode LEADING_ASTERISK(int i) {
3249                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3250                }
3251                public TrContext(ParserRuleContext parent, int invokingState) {
3252                        super(parent, invokingState);
3253                }
3254                @Override public int getRuleIndex() { return RULE_tr; }
3255                @Override
3256                public void enterRule(ParseTreeListener listener) {
3257                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this);
3258                }
3259                @Override
3260                public void exitRule(ParseTreeListener listener) {
3261                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this);
3262                }
3263                @Override
3264                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3265                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this);
3266                        else return visitor.visitChildren(this);
3267                }
3268        }
3269
3270        public final TrContext tr() throws RecognitionException {
3271                TrContext _localctx = new TrContext(_ctx, getState());
3272                enterRule(_localctx, 28, RULE_tr);
3273                try {
3274                        int _alt;
3275                        enterOuterAlt(_localctx, 1);
3276                        {
3277                        setState(468);
3278                        trTagOpen();
3279                        setState(508);
3280                        _errHandler.sync(this);
3281                        _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3282                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3283                                if ( _alt==1 ) {
3284                                        {
3285                                        setState(506);
3286                                        _errHandler.sync(this);
3287                                        switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
3288                                        case 1:
3289                                                {
3290                                                setState(469);
3291                                                htmlTag();
3292                                                }
3293                                                break;
3294                                        case 2:
3295                                                {
3296                                                setState(470);
3297                                                singletonTag();
3298                                                }
3299                                                break;
3300                                        case 3:
3301                                                {
3302                                                setState(471);
3303                                                paragraph();
3304                                                }
3305                                                break;
3306                                        case 4:
3307                                                {
3308                                                setState(472);
3309                                                li();
3310                                                }
3311                                                break;
3312                                        case 5:
3313                                                {
3314                                                setState(473);
3315                                                td();
3316                                                }
3317                                                break;
3318                                        case 6:
3319                                                {
3320                                                setState(474);
3321                                                th();
3322                                                }
3323                                                break;
3324                                        case 7:
3325                                                {
3326                                                setState(475);
3327                                                body();
3328                                                }
3329                                                break;
3330                                        case 8:
3331                                                {
3332                                                setState(476);
3333                                                colgroup();
3334                                                }
3335                                                break;
3336                                        case 9:
3337                                                {
3338                                                setState(477);
3339                                                dd();
3340                                                }
3341                                                break;
3342                                        case 10:
3343                                                {
3344                                                setState(478);
3345                                                dt();
3346                                                }
3347                                                break;
3348                                        case 11:
3349                                                {
3350                                                setState(479);
3351                                                head();
3352                                                }
3353                                                break;
3354                                        case 12:
3355                                                {
3356                                                setState(480);
3357                                                html();
3358                                                }
3359                                                break;
3360                                        case 13:
3361                                                {
3362                                                setState(481);
3363                                                option();
3364                                                }
3365                                                break;
3366                                        case 14:
3367                                                {
3368                                                setState(482);
3369                                                tbody();
3370                                                }
3371                                                break;
3372                                        case 15:
3373                                                {
3374                                                setState(483);
3375                                                thead();
3376                                                }
3377                                                break;
3378                                        case 16:
3379                                                {
3380                                                setState(484);
3381                                                tfoot();
3382                                                }
3383                                                break;
3384                                        case 17:
3385                                                {
3386                                                setState(485);
3387                                                pTagOpen();
3388                                                }
3389                                                break;
3390                                        case 18:
3391                                                {
3392                                                setState(486);
3393                                                liTagOpen();
3394                                                }
3395                                                break;
3396                                        case 19:
3397                                                {
3398                                                setState(487);
3399                                                tdTagOpen();
3400                                                }
3401                                                break;
3402                                        case 20:
3403                                                {
3404                                                setState(488);
3405                                                thTagOpen();
3406                                                }
3407                                                break;
3408                                        case 21:
3409                                                {
3410                                                setState(489);
3411                                                bodyTagOpen();
3412                                                }
3413                                                break;
3414                                        case 22:
3415                                                {
3416                                                setState(490);
3417                                                colgroupTagOpen();
3418                                                }
3419                                                break;
3420                                        case 23:
3421                                                {
3422                                                setState(491);
3423                                                ddTagOpen();
3424                                                }
3425                                                break;
3426                                        case 24:
3427                                                {
3428                                                setState(492);
3429                                                dtTagOpen();
3430                                                }
3431                                                break;
3432                                        case 25:
3433                                                {
3434                                                setState(493);
3435                                                headTagOpen();
3436                                                }
3437                                                break;
3438                                        case 26:
3439                                                {
3440                                                setState(494);
3441                                                htmlTagOpen();
3442                                                }
3443                                                break;
3444                                        case 27:
3445                                                {
3446                                                setState(495);
3447                                                optionTagOpen();
3448                                                }
3449                                                break;
3450                                        case 28:
3451                                                {
3452                                                setState(496);
3453                                                tbodyTagOpen();
3454                                                }
3455                                                break;
3456                                        case 29:
3457                                                {
3458                                                setState(497);
3459                                                theadTagOpen();
3460                                                }
3461                                                break;
3462                                        case 30:
3463                                                {
3464                                                setState(498);
3465                                                tfootTagOpen();
3466                                                }
3467                                                break;
3468                                        case 31:
3469                                                {
3470                                                {
3471                                                setState(499);
3472                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3473                                                setState(500);
3474                                                match(LEADING_ASTERISK);
3475                                                }
3476                                                }
3477                                                break;
3478                                        case 32:
3479                                                {
3480                                                setState(501);
3481                                                htmlComment();
3482                                                }
3483                                                break;
3484                                        case 33:
3485                                                {
3486                                                setState(502);
3487                                                match(CDATA);
3488                                                }
3489                                                break;
3490                                        case 34:
3491                                                {
3492                                                setState(503);
3493                                                match(NEWLINE);
3494                                                }
3495                                                break;
3496                                        case 35:
3497                                                {
3498                                                setState(504);
3499                                                text();
3500                                                }
3501                                                break;
3502                                        case 36:
3503                                                {
3504                                                setState(505);
3505                                                javadocInlineTag();
3506                                                }
3507                                                break;
3508                                        }
3509                                        } 
3510                                }
3511                                setState(510);
3512                                _errHandler.sync(this);
3513                                _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3514                        }
3515                        setState(511);
3516                        trTagClose();
3517                        }
3518                }
3519                catch (RecognitionException re) {
3520                        _localctx.exception = re;
3521                        _errHandler.reportError(this, re);
3522                        _errHandler.recover(this, re);
3523                }
3524                finally {
3525                        exitRule();
3526                }
3527                return _localctx;
3528        }
3529
3530        public static class TdTagOpenContext extends ParserRuleContext {
3531                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3532                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3533                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3534                public List<AttributeContext> attribute() {
3535                        return getRuleContexts(AttributeContext.class);
3536                }
3537                public AttributeContext attribute(int i) {
3538                        return getRuleContext(AttributeContext.class,i);
3539                }
3540                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3541                public TerminalNode NEWLINE(int i) {
3542                        return getToken(JavadocParser.NEWLINE, i);
3543                }
3544                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3545                public TerminalNode LEADING_ASTERISK(int i) {
3546                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3547                }
3548                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3549                public TerminalNode WS(int i) {
3550                        return getToken(JavadocParser.WS, i);
3551                }
3552                public TdTagOpenContext(ParserRuleContext parent, int invokingState) {
3553                        super(parent, invokingState);
3554                }
3555                @Override public int getRuleIndex() { return RULE_tdTagOpen; }
3556                @Override
3557                public void enterRule(ParseTreeListener listener) {
3558                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this);
3559                }
3560                @Override
3561                public void exitRule(ParseTreeListener listener) {
3562                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this);
3563                }
3564                @Override
3565                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3566                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this);
3567                        else return visitor.visitChildren(this);
3568                }
3569        }
3570
3571        public final TdTagOpenContext tdTagOpen() throws RecognitionException {
3572                TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState());
3573                enterRule(_localctx, 30, RULE_tdTagOpen);
3574                int _la;
3575                try {
3576                        enterOuterAlt(_localctx, 1);
3577                        {
3578                        setState(513);
3579                        match(OPEN);
3580                        setState(514);
3581                        match(TD_HTML_TAG_NAME);
3582                        setState(521);
3583                        _errHandler.sync(this);
3584                        _la = _input.LA(1);
3585                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3586                                {
3587                                setState(519);
3588                                _errHandler.sync(this);
3589                                switch (_input.LA(1)) {
3590                                case HTML_TAG_NAME:
3591                                        {
3592                                        setState(515);
3593                                        attribute();
3594                                        }
3595                                        break;
3596                                case NEWLINE:
3597                                        {
3598                                        setState(516);
3599                                        match(NEWLINE);
3600                                        }
3601                                        break;
3602                                case LEADING_ASTERISK:
3603                                        {
3604                                        setState(517);
3605                                        match(LEADING_ASTERISK);
3606                                        }
3607                                        break;
3608                                case WS:
3609                                        {
3610                                        setState(518);
3611                                        match(WS);
3612                                        }
3613                                        break;
3614                                default:
3615                                        throw new NoViableAltException(this);
3616                                }
3617                                }
3618                                setState(523);
3619                                _errHandler.sync(this);
3620                                _la = _input.LA(1);
3621                        }
3622                        setState(524);
3623                        match(CLOSE);
3624                        }
3625                }
3626                catch (RecognitionException re) {
3627                        _localctx.exception = re;
3628                        _errHandler.reportError(this, re);
3629                        _errHandler.recover(this, re);
3630                }
3631                finally {
3632                        exitRule();
3633                }
3634                return _localctx;
3635        }
3636
3637        public static class TdTagCloseContext extends ParserRuleContext {
3638                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3639                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3640                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3641                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3642                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3643                public TerminalNode NEWLINE(int i) {
3644                        return getToken(JavadocParser.NEWLINE, i);
3645                }
3646                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3647                public TerminalNode LEADING_ASTERISK(int i) {
3648                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3649                }
3650                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3651                public TerminalNode WS(int i) {
3652                        return getToken(JavadocParser.WS, i);
3653                }
3654                public TdTagCloseContext(ParserRuleContext parent, int invokingState) {
3655                        super(parent, invokingState);
3656                }
3657                @Override public int getRuleIndex() { return RULE_tdTagClose; }
3658                @Override
3659                public void enterRule(ParseTreeListener listener) {
3660                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this);
3661                }
3662                @Override
3663                public void exitRule(ParseTreeListener listener) {
3664                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this);
3665                }
3666                @Override
3667                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3668                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this);
3669                        else return visitor.visitChildren(this);
3670                }
3671        }
3672
3673        public final TdTagCloseContext tdTagClose() throws RecognitionException {
3674                TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState());
3675                enterRule(_localctx, 32, RULE_tdTagClose);
3676                int _la;
3677                try {
3678                        enterOuterAlt(_localctx, 1);
3679                        {
3680                        setState(526);
3681                        match(OPEN);
3682                        setState(527);
3683                        match(SLASH);
3684                        setState(528);
3685                        match(TD_HTML_TAG_NAME);
3686                        setState(532);
3687                        _errHandler.sync(this);
3688                        _la = _input.LA(1);
3689                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3690                                {
3691                                {
3692                                setState(529);
3693                                _la = _input.LA(1);
3694                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3695                                _errHandler.recoverInline(this);
3696                                }
3697                                else {
3698                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
3699                                        _errHandler.reportMatch(this);
3700                                        consume();
3701                                }
3702                                }
3703                                }
3704                                setState(534);
3705                                _errHandler.sync(this);
3706                                _la = _input.LA(1);
3707                        }
3708                        setState(535);
3709                        match(CLOSE);
3710                        }
3711                }
3712                catch (RecognitionException re) {
3713                        _localctx.exception = re;
3714                        _errHandler.reportError(this, re);
3715                        _errHandler.recover(this, re);
3716                }
3717                finally {
3718                        exitRule();
3719                }
3720                return _localctx;
3721        }
3722
3723        public static class TdContext extends ParserRuleContext {
3724                public List<TdTagOpenContext> tdTagOpen() {
3725                        return getRuleContexts(TdTagOpenContext.class);
3726                }
3727                public TdTagOpenContext tdTagOpen(int i) {
3728                        return getRuleContext(TdTagOpenContext.class,i);
3729                }
3730                public TdTagCloseContext tdTagClose() {
3731                        return getRuleContext(TdTagCloseContext.class,0);
3732                }
3733                public List<HtmlTagContext> htmlTag() {
3734                        return getRuleContexts(HtmlTagContext.class);
3735                }
3736                public HtmlTagContext htmlTag(int i) {
3737                        return getRuleContext(HtmlTagContext.class,i);
3738                }
3739                public List<SingletonTagContext> singletonTag() {
3740                        return getRuleContexts(SingletonTagContext.class);
3741                }
3742                public SingletonTagContext singletonTag(int i) {
3743                        return getRuleContext(SingletonTagContext.class,i);
3744                }
3745                public List<ParagraphContext> paragraph() {
3746                        return getRuleContexts(ParagraphContext.class);
3747                }
3748                public ParagraphContext paragraph(int i) {
3749                        return getRuleContext(ParagraphContext.class,i);
3750                }
3751                public List<LiContext> li() {
3752                        return getRuleContexts(LiContext.class);
3753                }
3754                public LiContext li(int i) {
3755                        return getRuleContext(LiContext.class,i);
3756                }
3757                public List<TrContext> tr() {
3758                        return getRuleContexts(TrContext.class);
3759                }
3760                public TrContext tr(int i) {
3761                        return getRuleContext(TrContext.class,i);
3762                }
3763                public List<ThContext> th() {
3764                        return getRuleContexts(ThContext.class);
3765                }
3766                public ThContext th(int i) {
3767                        return getRuleContext(ThContext.class,i);
3768                }
3769                public List<BodyContext> body() {
3770                        return getRuleContexts(BodyContext.class);
3771                }
3772                public BodyContext body(int i) {
3773                        return getRuleContext(BodyContext.class,i);
3774                }
3775                public List<ColgroupContext> colgroup() {
3776                        return getRuleContexts(ColgroupContext.class);
3777                }
3778                public ColgroupContext colgroup(int i) {
3779                        return getRuleContext(ColgroupContext.class,i);
3780                }
3781                public List<DdContext> dd() {
3782                        return getRuleContexts(DdContext.class);
3783                }
3784                public DdContext dd(int i) {
3785                        return getRuleContext(DdContext.class,i);
3786                }
3787                public List<DtContext> dt() {
3788                        return getRuleContexts(DtContext.class);
3789                }
3790                public DtContext dt(int i) {
3791                        return getRuleContext(DtContext.class,i);
3792                }
3793                public List<HeadContext> head() {
3794                        return getRuleContexts(HeadContext.class);
3795                }
3796                public HeadContext head(int i) {
3797                        return getRuleContext(HeadContext.class,i);
3798                }
3799                public List<HtmlContext> html() {
3800                        return getRuleContexts(HtmlContext.class);
3801                }
3802                public HtmlContext html(int i) {
3803                        return getRuleContext(HtmlContext.class,i);
3804                }
3805                public List<OptionContext> option() {
3806                        return getRuleContexts(OptionContext.class);
3807                }
3808                public OptionContext option(int i) {
3809                        return getRuleContext(OptionContext.class,i);
3810                }
3811                public List<TbodyContext> tbody() {
3812                        return getRuleContexts(TbodyContext.class);
3813                }
3814                public TbodyContext tbody(int i) {
3815                        return getRuleContext(TbodyContext.class,i);
3816                }
3817                public List<TheadContext> thead() {
3818                        return getRuleContexts(TheadContext.class);
3819                }
3820                public TheadContext thead(int i) {
3821                        return getRuleContext(TheadContext.class,i);
3822                }
3823                public List<TfootContext> tfoot() {
3824                        return getRuleContexts(TfootContext.class);
3825                }
3826                public TfootContext tfoot(int i) {
3827                        return getRuleContext(TfootContext.class,i);
3828                }
3829                public List<PTagOpenContext> pTagOpen() {
3830                        return getRuleContexts(PTagOpenContext.class);
3831                }
3832                public PTagOpenContext pTagOpen(int i) {
3833                        return getRuleContext(PTagOpenContext.class,i);
3834                }
3835                public List<LiTagOpenContext> liTagOpen() {
3836                        return getRuleContexts(LiTagOpenContext.class);
3837                }
3838                public LiTagOpenContext liTagOpen(int i) {
3839                        return getRuleContext(LiTagOpenContext.class,i);
3840                }
3841                public List<ThTagOpenContext> thTagOpen() {
3842                        return getRuleContexts(ThTagOpenContext.class);
3843                }
3844                public ThTagOpenContext thTagOpen(int i) {
3845                        return getRuleContext(ThTagOpenContext.class,i);
3846                }
3847                public List<BodyTagOpenContext> bodyTagOpen() {
3848                        return getRuleContexts(BodyTagOpenContext.class);
3849                }
3850                public BodyTagOpenContext bodyTagOpen(int i) {
3851                        return getRuleContext(BodyTagOpenContext.class,i);
3852                }
3853                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3854                        return getRuleContexts(ColgroupTagOpenContext.class);
3855                }
3856                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3857                        return getRuleContext(ColgroupTagOpenContext.class,i);
3858                }
3859                public List<DdTagOpenContext> ddTagOpen() {
3860                        return getRuleContexts(DdTagOpenContext.class);
3861                }
3862                public DdTagOpenContext ddTagOpen(int i) {
3863                        return getRuleContext(DdTagOpenContext.class,i);
3864                }
3865                public List<DtTagOpenContext> dtTagOpen() {
3866                        return getRuleContexts(DtTagOpenContext.class);
3867                }
3868                public DtTagOpenContext dtTagOpen(int i) {
3869                        return getRuleContext(DtTagOpenContext.class,i);
3870                }
3871                public List<HeadTagOpenContext> headTagOpen() {
3872                        return getRuleContexts(HeadTagOpenContext.class);
3873                }
3874                public HeadTagOpenContext headTagOpen(int i) {
3875                        return getRuleContext(HeadTagOpenContext.class,i);
3876                }
3877                public List<HtmlTagOpenContext> htmlTagOpen() {
3878                        return getRuleContexts(HtmlTagOpenContext.class);
3879                }
3880                public HtmlTagOpenContext htmlTagOpen(int i) {
3881                        return getRuleContext(HtmlTagOpenContext.class,i);
3882                }
3883                public List<OptionTagOpenContext> optionTagOpen() {
3884                        return getRuleContexts(OptionTagOpenContext.class);
3885                }
3886                public OptionTagOpenContext optionTagOpen(int i) {
3887                        return getRuleContext(OptionTagOpenContext.class,i);
3888                }
3889                public List<TbodyTagOpenContext> tbodyTagOpen() {
3890                        return getRuleContexts(TbodyTagOpenContext.class);
3891                }
3892                public TbodyTagOpenContext tbodyTagOpen(int i) {
3893                        return getRuleContext(TbodyTagOpenContext.class,i);
3894                }
3895                public List<TheadTagOpenContext> theadTagOpen() {
3896                        return getRuleContexts(TheadTagOpenContext.class);
3897                }
3898                public TheadTagOpenContext theadTagOpen(int i) {
3899                        return getRuleContext(TheadTagOpenContext.class,i);
3900                }
3901                public List<TfootTagOpenContext> tfootTagOpen() {
3902                        return getRuleContexts(TfootTagOpenContext.class);
3903                }
3904                public TfootTagOpenContext tfootTagOpen(int i) {
3905                        return getRuleContext(TfootTagOpenContext.class,i);
3906                }
3907                public List<HtmlCommentContext> htmlComment() {
3908                        return getRuleContexts(HtmlCommentContext.class);
3909                }
3910                public HtmlCommentContext htmlComment(int i) {
3911                        return getRuleContext(HtmlCommentContext.class,i);
3912                }
3913                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3914                public TerminalNode CDATA(int i) {
3915                        return getToken(JavadocParser.CDATA, i);
3916                }
3917                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3918                public TerminalNode NEWLINE(int i) {
3919                        return getToken(JavadocParser.NEWLINE, i);
3920                }
3921                public List<TextContext> text() {
3922                        return getRuleContexts(TextContext.class);
3923                }
3924                public TextContext text(int i) {
3925                        return getRuleContext(TextContext.class,i);
3926                }
3927                public List<JavadocInlineTagContext> javadocInlineTag() {
3928                        return getRuleContexts(JavadocInlineTagContext.class);
3929                }
3930                public JavadocInlineTagContext javadocInlineTag(int i) {
3931                        return getRuleContext(JavadocInlineTagContext.class,i);
3932                }
3933                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3934                public TerminalNode LEADING_ASTERISK(int i) {
3935                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3936                }
3937                public TdContext(ParserRuleContext parent, int invokingState) {
3938                        super(parent, invokingState);
3939                }
3940                @Override public int getRuleIndex() { return RULE_td; }
3941                @Override
3942                public void enterRule(ParseTreeListener listener) {
3943                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this);
3944                }
3945                @Override
3946                public void exitRule(ParseTreeListener listener) {
3947                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this);
3948                }
3949                @Override
3950                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3951                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this);
3952                        else return visitor.visitChildren(this);
3953                }
3954        }
3955
3956        public final TdContext td() throws RecognitionException {
3957                TdContext _localctx = new TdContext(_ctx, getState());
3958                enterRule(_localctx, 34, RULE_td);
3959                try {
3960                        int _alt;
3961                        enterOuterAlt(_localctx, 1);
3962                        {
3963                        setState(537);
3964                        tdTagOpen();
3965                        setState(577);
3966                        _errHandler.sync(this);
3967                        _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
3968                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3969                                if ( _alt==1 ) {
3970                                        {
3971                                        setState(575);
3972                                        _errHandler.sync(this);
3973                                        switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
3974                                        case 1:
3975                                                {
3976                                                setState(538);
3977                                                htmlTag();
3978                                                }
3979                                                break;
3980                                        case 2:
3981                                                {
3982                                                setState(539);
3983                                                singletonTag();
3984                                                }
3985                                                break;
3986                                        case 3:
3987                                                {
3988                                                setState(540);
3989                                                paragraph();
3990                                                }
3991                                                break;
3992                                        case 4:
3993                                                {
3994                                                setState(541);
3995                                                li();
3996                                                }
3997                                                break;
3998                                        case 5:
3999                                                {
4000                                                setState(542);
4001                                                tr();
4002                                                }
4003                                                break;
4004                                        case 6:
4005                                                {
4006                                                setState(543);
4007                                                th();
4008                                                }
4009                                                break;
4010                                        case 7:
4011                                                {
4012                                                setState(544);
4013                                                body();
4014                                                }
4015                                                break;
4016                                        case 8:
4017                                                {
4018                                                setState(545);
4019                                                colgroup();
4020                                                }
4021                                                break;
4022                                        case 9:
4023                                                {
4024                                                setState(546);
4025                                                dd();
4026                                                }
4027                                                break;
4028                                        case 10:
4029                                                {
4030                                                setState(547);
4031                                                dt();
4032                                                }
4033                                                break;
4034                                        case 11:
4035                                                {
4036                                                setState(548);
4037                                                head();
4038                                                }
4039                                                break;
4040                                        case 12:
4041                                                {
4042                                                setState(549);
4043                                                html();
4044                                                }
4045                                                break;
4046                                        case 13:
4047                                                {
4048                                                setState(550);
4049                                                option();
4050                                                }
4051                                                break;
4052                                        case 14:
4053                                                {
4054                                                setState(551);
4055                                                tbody();
4056                                                }
4057                                                break;
4058                                        case 15:
4059                                                {
4060                                                setState(552);
4061                                                thead();
4062                                                }
4063                                                break;
4064                                        case 16:
4065                                                {
4066                                                setState(553);
4067                                                tfoot();
4068                                                }
4069                                                break;
4070                                        case 17:
4071                                                {
4072                                                setState(554);
4073                                                pTagOpen();
4074                                                }
4075                                                break;
4076                                        case 18:
4077                                                {
4078                                                setState(555);
4079                                                liTagOpen();
4080                                                }
4081                                                break;
4082                                        case 19:
4083                                                {
4084                                                setState(556);
4085                                                tdTagOpen();
4086                                                }
4087                                                break;
4088                                        case 20:
4089                                                {
4090                                                setState(557);
4091                                                thTagOpen();
4092                                                }
4093                                                break;
4094                                        case 21:
4095                                                {
4096                                                setState(558);
4097                                                bodyTagOpen();
4098                                                }
4099                                                break;
4100                                        case 22:
4101                                                {
4102                                                setState(559);
4103                                                colgroupTagOpen();
4104                                                }
4105                                                break;
4106                                        case 23:
4107                                                {
4108                                                setState(560);
4109                                                ddTagOpen();
4110                                                }
4111                                                break;
4112                                        case 24:
4113                                                {
4114                                                setState(561);
4115                                                dtTagOpen();
4116                                                }
4117                                                break;
4118                                        case 25:
4119                                                {
4120                                                setState(562);
4121                                                headTagOpen();
4122                                                }
4123                                                break;
4124                                        case 26:
4125                                                {
4126                                                setState(563);
4127                                                htmlTagOpen();
4128                                                }
4129                                                break;
4130                                        case 27:
4131                                                {
4132                                                setState(564);
4133                                                optionTagOpen();
4134                                                }
4135                                                break;
4136                                        case 28:
4137                                                {
4138                                                setState(565);
4139                                                tbodyTagOpen();
4140                                                }
4141                                                break;
4142                                        case 29:
4143                                                {
4144                                                setState(566);
4145                                                theadTagOpen();
4146                                                }
4147                                                break;
4148                                        case 30:
4149                                                {
4150                                                setState(567);
4151                                                tfootTagOpen();
4152                                                }
4153                                                break;
4154                                        case 31:
4155                                                {
4156                                                {
4157                                                setState(568);
4158                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4159                                                setState(569);
4160                                                match(LEADING_ASTERISK);
4161                                                }
4162                                                }
4163                                                break;
4164                                        case 32:
4165                                                {
4166                                                setState(570);
4167                                                htmlComment();
4168                                                }
4169                                                break;
4170                                        case 33:
4171                                                {
4172                                                setState(571);
4173                                                match(CDATA);
4174                                                }
4175                                                break;
4176                                        case 34:
4177                                                {
4178                                                setState(572);
4179                                                match(NEWLINE);
4180                                                }
4181                                                break;
4182                                        case 35:
4183                                                {
4184                                                setState(573);
4185                                                text();
4186                                                }
4187                                                break;
4188                                        case 36:
4189                                                {
4190                                                setState(574);
4191                                                javadocInlineTag();
4192                                                }
4193                                                break;
4194                                        }
4195                                        } 
4196                                }
4197                                setState(579);
4198                                _errHandler.sync(this);
4199                                _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
4200                        }
4201                        setState(580);
4202                        tdTagClose();
4203                        }
4204                }
4205                catch (RecognitionException re) {
4206                        _localctx.exception = re;
4207                        _errHandler.reportError(this, re);
4208                        _errHandler.recover(this, re);
4209                }
4210                finally {
4211                        exitRule();
4212                }
4213                return _localctx;
4214        }
4215
4216        public static class ThTagOpenContext extends ParserRuleContext {
4217                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4218                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4219                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4220                public List<AttributeContext> attribute() {
4221                        return getRuleContexts(AttributeContext.class);
4222                }
4223                public AttributeContext attribute(int i) {
4224                        return getRuleContext(AttributeContext.class,i);
4225                }
4226                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4227                public TerminalNode NEWLINE(int i) {
4228                        return getToken(JavadocParser.NEWLINE, i);
4229                }
4230                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4231                public TerminalNode LEADING_ASTERISK(int i) {
4232                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4233                }
4234                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4235                public TerminalNode WS(int i) {
4236                        return getToken(JavadocParser.WS, i);
4237                }
4238                public ThTagOpenContext(ParserRuleContext parent, int invokingState) {
4239                        super(parent, invokingState);
4240                }
4241                @Override public int getRuleIndex() { return RULE_thTagOpen; }
4242                @Override
4243                public void enterRule(ParseTreeListener listener) {
4244                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this);
4245                }
4246                @Override
4247                public void exitRule(ParseTreeListener listener) {
4248                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this);
4249                }
4250                @Override
4251                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4252                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this);
4253                        else return visitor.visitChildren(this);
4254                }
4255        }
4256
4257        public final ThTagOpenContext thTagOpen() throws RecognitionException {
4258                ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState());
4259                enterRule(_localctx, 36, RULE_thTagOpen);
4260                int _la;
4261                try {
4262                        enterOuterAlt(_localctx, 1);
4263                        {
4264                        setState(582);
4265                        match(OPEN);
4266                        setState(583);
4267                        match(TH_HTML_TAG_NAME);
4268                        setState(590);
4269                        _errHandler.sync(this);
4270                        _la = _input.LA(1);
4271                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4272                                {
4273                                setState(588);
4274                                _errHandler.sync(this);
4275                                switch (_input.LA(1)) {
4276                                case HTML_TAG_NAME:
4277                                        {
4278                                        setState(584);
4279                                        attribute();
4280                                        }
4281                                        break;
4282                                case NEWLINE:
4283                                        {
4284                                        setState(585);
4285                                        match(NEWLINE);
4286                                        }
4287                                        break;
4288                                case LEADING_ASTERISK:
4289                                        {
4290                                        setState(586);
4291                                        match(LEADING_ASTERISK);
4292                                        }
4293                                        break;
4294                                case WS:
4295                                        {
4296                                        setState(587);
4297                                        match(WS);
4298                                        }
4299                                        break;
4300                                default:
4301                                        throw new NoViableAltException(this);
4302                                }
4303                                }
4304                                setState(592);
4305                                _errHandler.sync(this);
4306                                _la = _input.LA(1);
4307                        }
4308                        setState(593);
4309                        match(CLOSE);
4310                        }
4311                }
4312                catch (RecognitionException re) {
4313                        _localctx.exception = re;
4314                        _errHandler.reportError(this, re);
4315                        _errHandler.recover(this, re);
4316                }
4317                finally {
4318                        exitRule();
4319                }
4320                return _localctx;
4321        }
4322
4323        public static class ThTagCloseContext extends ParserRuleContext {
4324                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4325                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4326                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4327                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4328                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4329                public TerminalNode NEWLINE(int i) {
4330                        return getToken(JavadocParser.NEWLINE, i);
4331                }
4332                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4333                public TerminalNode LEADING_ASTERISK(int i) {
4334                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4335                }
4336                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4337                public TerminalNode WS(int i) {
4338                        return getToken(JavadocParser.WS, i);
4339                }
4340                public ThTagCloseContext(ParserRuleContext parent, int invokingState) {
4341                        super(parent, invokingState);
4342                }
4343                @Override public int getRuleIndex() { return RULE_thTagClose; }
4344                @Override
4345                public void enterRule(ParseTreeListener listener) {
4346                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this);
4347                }
4348                @Override
4349                public void exitRule(ParseTreeListener listener) {
4350                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this);
4351                }
4352                @Override
4353                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4354                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this);
4355                        else return visitor.visitChildren(this);
4356                }
4357        }
4358
4359        public final ThTagCloseContext thTagClose() throws RecognitionException {
4360                ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState());
4361                enterRule(_localctx, 38, RULE_thTagClose);
4362                int _la;
4363                try {
4364                        enterOuterAlt(_localctx, 1);
4365                        {
4366                        setState(595);
4367                        match(OPEN);
4368                        setState(596);
4369                        match(SLASH);
4370                        setState(597);
4371                        match(TH_HTML_TAG_NAME);
4372                        setState(601);
4373                        _errHandler.sync(this);
4374                        _la = _input.LA(1);
4375                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4376                                {
4377                                {
4378                                setState(598);
4379                                _la = _input.LA(1);
4380                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4381                                _errHandler.recoverInline(this);
4382                                }
4383                                else {
4384                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
4385                                        _errHandler.reportMatch(this);
4386                                        consume();
4387                                }
4388                                }
4389                                }
4390                                setState(603);
4391                                _errHandler.sync(this);
4392                                _la = _input.LA(1);
4393                        }
4394                        setState(604);
4395                        match(CLOSE);
4396                        }
4397                }
4398                catch (RecognitionException re) {
4399                        _localctx.exception = re;
4400                        _errHandler.reportError(this, re);
4401                        _errHandler.recover(this, re);
4402                }
4403                finally {
4404                        exitRule();
4405                }
4406                return _localctx;
4407        }
4408
4409        public static class ThContext extends ParserRuleContext {
4410                public ThTagOpenContext thTagOpen() {
4411                        return getRuleContext(ThTagOpenContext.class,0);
4412                }
4413                public ThTagCloseContext thTagClose() {
4414                        return getRuleContext(ThTagCloseContext.class,0);
4415                }
4416                public List<HtmlTagContext> htmlTag() {
4417                        return getRuleContexts(HtmlTagContext.class);
4418                }
4419                public HtmlTagContext htmlTag(int i) {
4420                        return getRuleContext(HtmlTagContext.class,i);
4421                }
4422                public List<SingletonTagContext> singletonTag() {
4423                        return getRuleContexts(SingletonTagContext.class);
4424                }
4425                public SingletonTagContext singletonTag(int i) {
4426                        return getRuleContext(SingletonTagContext.class,i);
4427                }
4428                public List<ParagraphContext> paragraph() {
4429                        return getRuleContexts(ParagraphContext.class);
4430                }
4431                public ParagraphContext paragraph(int i) {
4432                        return getRuleContext(ParagraphContext.class,i);
4433                }
4434                public List<LiContext> li() {
4435                        return getRuleContexts(LiContext.class);
4436                }
4437                public LiContext li(int i) {
4438                        return getRuleContext(LiContext.class,i);
4439                }
4440                public List<TrContext> tr() {
4441                        return getRuleContexts(TrContext.class);
4442                }
4443                public TrContext tr(int i) {
4444                        return getRuleContext(TrContext.class,i);
4445                }
4446                public List<TdContext> td() {
4447                        return getRuleContexts(TdContext.class);
4448                }
4449                public TdContext td(int i) {
4450                        return getRuleContext(TdContext.class,i);
4451                }
4452                public List<BodyContext> body() {
4453                        return getRuleContexts(BodyContext.class);
4454                }
4455                public BodyContext body(int i) {
4456                        return getRuleContext(BodyContext.class,i);
4457                }
4458                public List<ColgroupContext> colgroup() {
4459                        return getRuleContexts(ColgroupContext.class);
4460                }
4461                public ColgroupContext colgroup(int i) {
4462                        return getRuleContext(ColgroupContext.class,i);
4463                }
4464                public List<DdContext> dd() {
4465                        return getRuleContexts(DdContext.class);
4466                }
4467                public DdContext dd(int i) {
4468                        return getRuleContext(DdContext.class,i);
4469                }
4470                public List<DtContext> dt() {
4471                        return getRuleContexts(DtContext.class);
4472                }
4473                public DtContext dt(int i) {
4474                        return getRuleContext(DtContext.class,i);
4475                }
4476                public List<HeadContext> head() {
4477                        return getRuleContexts(HeadContext.class);
4478                }
4479                public HeadContext head(int i) {
4480                        return getRuleContext(HeadContext.class,i);
4481                }
4482                public List<HtmlContext> html() {
4483                        return getRuleContexts(HtmlContext.class);
4484                }
4485                public HtmlContext html(int i) {
4486                        return getRuleContext(HtmlContext.class,i);
4487                }
4488                public List<OptionContext> option() {
4489                        return getRuleContexts(OptionContext.class);
4490                }
4491                public OptionContext option(int i) {
4492                        return getRuleContext(OptionContext.class,i);
4493                }
4494                public List<TbodyContext> tbody() {
4495                        return getRuleContexts(TbodyContext.class);
4496                }
4497                public TbodyContext tbody(int i) {
4498                        return getRuleContext(TbodyContext.class,i);
4499                }
4500                public List<TheadContext> thead() {
4501                        return getRuleContexts(TheadContext.class);
4502                }
4503                public TheadContext thead(int i) {
4504                        return getRuleContext(TheadContext.class,i);
4505                }
4506                public List<TfootContext> tfoot() {
4507                        return getRuleContexts(TfootContext.class);
4508                }
4509                public TfootContext tfoot(int i) {
4510                        return getRuleContext(TfootContext.class,i);
4511                }
4512                public List<PTagOpenContext> pTagOpen() {
4513                        return getRuleContexts(PTagOpenContext.class);
4514                }
4515                public PTagOpenContext pTagOpen(int i) {
4516                        return getRuleContext(PTagOpenContext.class,i);
4517                }
4518                public List<LiTagOpenContext> liTagOpen() {
4519                        return getRuleContexts(LiTagOpenContext.class);
4520                }
4521                public LiTagOpenContext liTagOpen(int i) {
4522                        return getRuleContext(LiTagOpenContext.class,i);
4523                }
4524                public List<TrTagOpenContext> trTagOpen() {
4525                        return getRuleContexts(TrTagOpenContext.class);
4526                }
4527                public TrTagOpenContext trTagOpen(int i) {
4528                        return getRuleContext(TrTagOpenContext.class,i);
4529                }
4530                public List<TdTagOpenContext> tdTagOpen() {
4531                        return getRuleContexts(TdTagOpenContext.class);
4532                }
4533                public TdTagOpenContext tdTagOpen(int i) {
4534                        return getRuleContext(TdTagOpenContext.class,i);
4535                }
4536                public List<BodyTagOpenContext> bodyTagOpen() {
4537                        return getRuleContexts(BodyTagOpenContext.class);
4538                }
4539                public BodyTagOpenContext bodyTagOpen(int i) {
4540                        return getRuleContext(BodyTagOpenContext.class,i);
4541                }
4542                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4543                        return getRuleContexts(ColgroupTagOpenContext.class);
4544                }
4545                public ColgroupTagOpenContext colgroupTagOpen(int i) {
4546                        return getRuleContext(ColgroupTagOpenContext.class,i);
4547                }
4548                public List<DdTagOpenContext> ddTagOpen() {
4549                        return getRuleContexts(DdTagOpenContext.class);
4550                }
4551                public DdTagOpenContext ddTagOpen(int i) {
4552                        return getRuleContext(DdTagOpenContext.class,i);
4553                }
4554                public List<DtTagOpenContext> dtTagOpen() {
4555                        return getRuleContexts(DtTagOpenContext.class);
4556                }
4557                public DtTagOpenContext dtTagOpen(int i) {
4558                        return getRuleContext(DtTagOpenContext.class,i);
4559                }
4560                public List<HeadTagOpenContext> headTagOpen() {
4561                        return getRuleContexts(HeadTagOpenContext.class);
4562                }
4563                public HeadTagOpenContext headTagOpen(int i) {
4564                        return getRuleContext(HeadTagOpenContext.class,i);
4565                }
4566                public List<HtmlTagOpenContext> htmlTagOpen() {
4567                        return getRuleContexts(HtmlTagOpenContext.class);
4568                }
4569                public HtmlTagOpenContext htmlTagOpen(int i) {
4570                        return getRuleContext(HtmlTagOpenContext.class,i);
4571                }
4572                public List<OptionTagOpenContext> optionTagOpen() {
4573                        return getRuleContexts(OptionTagOpenContext.class);
4574                }
4575                public OptionTagOpenContext optionTagOpen(int i) {
4576                        return getRuleContext(OptionTagOpenContext.class,i);
4577                }
4578                public List<TbodyTagOpenContext> tbodyTagOpen() {
4579                        return getRuleContexts(TbodyTagOpenContext.class);
4580                }
4581                public TbodyTagOpenContext tbodyTagOpen(int i) {
4582                        return getRuleContext(TbodyTagOpenContext.class,i);
4583                }
4584                public List<TheadTagOpenContext> theadTagOpen() {
4585                        return getRuleContexts(TheadTagOpenContext.class);
4586                }
4587                public TheadTagOpenContext theadTagOpen(int i) {
4588                        return getRuleContext(TheadTagOpenContext.class,i);
4589                }
4590                public List<TfootTagOpenContext> tfootTagOpen() {
4591                        return getRuleContexts(TfootTagOpenContext.class);
4592                }
4593                public TfootTagOpenContext tfootTagOpen(int i) {
4594                        return getRuleContext(TfootTagOpenContext.class,i);
4595                }
4596                public List<HtmlCommentContext> htmlComment() {
4597                        return getRuleContexts(HtmlCommentContext.class);
4598                }
4599                public HtmlCommentContext htmlComment(int i) {
4600                        return getRuleContext(HtmlCommentContext.class,i);
4601                }
4602                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4603                public TerminalNode CDATA(int i) {
4604                        return getToken(JavadocParser.CDATA, i);
4605                }
4606                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4607                public TerminalNode NEWLINE(int i) {
4608                        return getToken(JavadocParser.NEWLINE, i);
4609                }
4610                public List<TextContext> text() {
4611                        return getRuleContexts(TextContext.class);
4612                }
4613                public TextContext text(int i) {
4614                        return getRuleContext(TextContext.class,i);
4615                }
4616                public List<JavadocInlineTagContext> javadocInlineTag() {
4617                        return getRuleContexts(JavadocInlineTagContext.class);
4618                }
4619                public JavadocInlineTagContext javadocInlineTag(int i) {
4620                        return getRuleContext(JavadocInlineTagContext.class,i);
4621                }
4622                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4623                public TerminalNode LEADING_ASTERISK(int i) {
4624                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4625                }
4626                public ThContext(ParserRuleContext parent, int invokingState) {
4627                        super(parent, invokingState);
4628                }
4629                @Override public int getRuleIndex() { return RULE_th; }
4630                @Override
4631                public void enterRule(ParseTreeListener listener) {
4632                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this);
4633                }
4634                @Override
4635                public void exitRule(ParseTreeListener listener) {
4636                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this);
4637                }
4638                @Override
4639                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4640                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this);
4641                        else return visitor.visitChildren(this);
4642                }
4643        }
4644
4645        public final ThContext th() throws RecognitionException {
4646                ThContext _localctx = new ThContext(_ctx, getState());
4647                enterRule(_localctx, 40, RULE_th);
4648                try {
4649                        int _alt;
4650                        enterOuterAlt(_localctx, 1);
4651                        {
4652                        setState(606);
4653                        thTagOpen();
4654                        setState(646);
4655                        _errHandler.sync(this);
4656                        _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4657                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4658                                if ( _alt==1 ) {
4659                                        {
4660                                        setState(644);
4661                                        _errHandler.sync(this);
4662                                        switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
4663                                        case 1:
4664                                                {
4665                                                setState(607);
4666                                                htmlTag();
4667                                                }
4668                                                break;
4669                                        case 2:
4670                                                {
4671                                                setState(608);
4672                                                singletonTag();
4673                                                }
4674                                                break;
4675                                        case 3:
4676                                                {
4677                                                setState(609);
4678                                                paragraph();
4679                                                }
4680                                                break;
4681                                        case 4:
4682                                                {
4683                                                setState(610);
4684                                                li();
4685                                                }
4686                                                break;
4687                                        case 5:
4688                                                {
4689                                                setState(611);
4690                                                tr();
4691                                                }
4692                                                break;
4693                                        case 6:
4694                                                {
4695                                                setState(612);
4696                                                td();
4697                                                }
4698                                                break;
4699                                        case 7:
4700                                                {
4701                                                setState(613);
4702                                                body();
4703                                                }
4704                                                break;
4705                                        case 8:
4706                                                {
4707                                                setState(614);
4708                                                colgroup();
4709                                                }
4710                                                break;
4711                                        case 9:
4712                                                {
4713                                                setState(615);
4714                                                dd();
4715                                                }
4716                                                break;
4717                                        case 10:
4718                                                {
4719                                                setState(616);
4720                                                dt();
4721                                                }
4722                                                break;
4723                                        case 11:
4724                                                {
4725                                                setState(617);
4726                                                head();
4727                                                }
4728                                                break;
4729                                        case 12:
4730                                                {
4731                                                setState(618);
4732                                                html();
4733                                                }
4734                                                break;
4735                                        case 13:
4736                                                {
4737                                                setState(619);
4738                                                option();
4739                                                }
4740                                                break;
4741                                        case 14:
4742                                                {
4743                                                setState(620);
4744                                                tbody();
4745                                                }
4746                                                break;
4747                                        case 15:
4748                                                {
4749                                                setState(621);
4750                                                thead();
4751                                                }
4752                                                break;
4753                                        case 16:
4754                                                {
4755                                                setState(622);
4756                                                tfoot();
4757                                                }
4758                                                break;
4759                                        case 17:
4760                                                {
4761                                                setState(623);
4762                                                pTagOpen();
4763                                                }
4764                                                break;
4765                                        case 18:
4766                                                {
4767                                                setState(624);
4768                                                liTagOpen();
4769                                                }
4770                                                break;
4771                                        case 19:
4772                                                {
4773                                                setState(625);
4774                                                trTagOpen();
4775                                                }
4776                                                break;
4777                                        case 20:
4778                                                {
4779                                                setState(626);
4780                                                tdTagOpen();
4781                                                }
4782                                                break;
4783                                        case 21:
4784                                                {
4785                                                setState(627);
4786                                                bodyTagOpen();
4787                                                }
4788                                                break;
4789                                        case 22:
4790                                                {
4791                                                setState(628);
4792                                                colgroupTagOpen();
4793                                                }
4794                                                break;
4795                                        case 23:
4796                                                {
4797                                                setState(629);
4798                                                ddTagOpen();
4799                                                }
4800                                                break;
4801                                        case 24:
4802                                                {
4803                                                setState(630);
4804                                                dtTagOpen();
4805                                                }
4806                                                break;
4807                                        case 25:
4808                                                {
4809                                                setState(631);
4810                                                headTagOpen();
4811                                                }
4812                                                break;
4813                                        case 26:
4814                                                {
4815                                                setState(632);
4816                                                htmlTagOpen();
4817                                                }
4818                                                break;
4819                                        case 27:
4820                                                {
4821                                                setState(633);
4822                                                optionTagOpen();
4823                                                }
4824                                                break;
4825                                        case 28:
4826                                                {
4827                                                setState(634);
4828                                                tbodyTagOpen();
4829                                                }
4830                                                break;
4831                                        case 29:
4832                                                {
4833                                                setState(635);
4834                                                theadTagOpen();
4835                                                }
4836                                                break;
4837                                        case 30:
4838                                                {
4839                                                setState(636);
4840                                                tfootTagOpen();
4841                                                }
4842                                                break;
4843                                        case 31:
4844                                                {
4845                                                {
4846                                                setState(637);
4847                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4848                                                setState(638);
4849                                                match(LEADING_ASTERISK);
4850                                                }
4851                                                }
4852                                                break;
4853                                        case 32:
4854                                                {
4855                                                setState(639);
4856                                                htmlComment();
4857                                                }
4858                                                break;
4859                                        case 33:
4860                                                {
4861                                                setState(640);
4862                                                match(CDATA);
4863                                                }
4864                                                break;
4865                                        case 34:
4866                                                {
4867                                                setState(641);
4868                                                match(NEWLINE);
4869                                                }
4870                                                break;
4871                                        case 35:
4872                                                {
4873                                                setState(642);
4874                                                text();
4875                                                }
4876                                                break;
4877                                        case 36:
4878                                                {
4879                                                setState(643);
4880                                                javadocInlineTag();
4881                                                }
4882                                                break;
4883                                        }
4884                                        } 
4885                                }
4886                                setState(648);
4887                                _errHandler.sync(this);
4888                                _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4889                        }
4890                        setState(649);
4891                        thTagClose();
4892                        }
4893                }
4894                catch (RecognitionException re) {
4895                        _localctx.exception = re;
4896                        _errHandler.reportError(this, re);
4897                        _errHandler.recover(this, re);
4898                }
4899                finally {
4900                        exitRule();
4901                }
4902                return _localctx;
4903        }
4904
4905        public static class BodyTagOpenContext extends ParserRuleContext {
4906                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4907                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4908                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4909                public List<AttributeContext> attribute() {
4910                        return getRuleContexts(AttributeContext.class);
4911                }
4912                public AttributeContext attribute(int i) {
4913                        return getRuleContext(AttributeContext.class,i);
4914                }
4915                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4916                public TerminalNode NEWLINE(int i) {
4917                        return getToken(JavadocParser.NEWLINE, i);
4918                }
4919                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4920                public TerminalNode LEADING_ASTERISK(int i) {
4921                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4922                }
4923                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4924                public TerminalNode WS(int i) {
4925                        return getToken(JavadocParser.WS, i);
4926                }
4927                public BodyTagOpenContext(ParserRuleContext parent, int invokingState) {
4928                        super(parent, invokingState);
4929                }
4930                @Override public int getRuleIndex() { return RULE_bodyTagOpen; }
4931                @Override
4932                public void enterRule(ParseTreeListener listener) {
4933                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this);
4934                }
4935                @Override
4936                public void exitRule(ParseTreeListener listener) {
4937                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this);
4938                }
4939                @Override
4940                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4941                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this);
4942                        else return visitor.visitChildren(this);
4943                }
4944        }
4945
4946        public final BodyTagOpenContext bodyTagOpen() throws RecognitionException {
4947                BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState());
4948                enterRule(_localctx, 42, RULE_bodyTagOpen);
4949                int _la;
4950                try {
4951                        enterOuterAlt(_localctx, 1);
4952                        {
4953                        setState(651);
4954                        match(OPEN);
4955                        setState(652);
4956                        match(BODY_HTML_TAG_NAME);
4957                        setState(659);
4958                        _errHandler.sync(this);
4959                        _la = _input.LA(1);
4960                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4961                                {
4962                                setState(657);
4963                                _errHandler.sync(this);
4964                                switch (_input.LA(1)) {
4965                                case HTML_TAG_NAME:
4966                                        {
4967                                        setState(653);
4968                                        attribute();
4969                                        }
4970                                        break;
4971                                case NEWLINE:
4972                                        {
4973                                        setState(654);
4974                                        match(NEWLINE);
4975                                        }
4976                                        break;
4977                                case LEADING_ASTERISK:
4978                                        {
4979                                        setState(655);
4980                                        match(LEADING_ASTERISK);
4981                                        }
4982                                        break;
4983                                case WS:
4984                                        {
4985                                        setState(656);
4986                                        match(WS);
4987                                        }
4988                                        break;
4989                                default:
4990                                        throw new NoViableAltException(this);
4991                                }
4992                                }
4993                                setState(661);
4994                                _errHandler.sync(this);
4995                                _la = _input.LA(1);
4996                        }
4997                        setState(662);
4998                        match(CLOSE);
4999                        }
5000                }
5001                catch (RecognitionException re) {
5002                        _localctx.exception = re;
5003                        _errHandler.reportError(this, re);
5004                        _errHandler.recover(this, re);
5005                }
5006                finally {
5007                        exitRule();
5008                }
5009                return _localctx;
5010        }
5011
5012        public static class BodyTagCloseContext extends ParserRuleContext {
5013                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5014                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5015                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
5016                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5017                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5018                public TerminalNode NEWLINE(int i) {
5019                        return getToken(JavadocParser.NEWLINE, i);
5020                }
5021                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5022                public TerminalNode LEADING_ASTERISK(int i) {
5023                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5024                }
5025                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5026                public TerminalNode WS(int i) {
5027                        return getToken(JavadocParser.WS, i);
5028                }
5029                public BodyTagCloseContext(ParserRuleContext parent, int invokingState) {
5030                        super(parent, invokingState);
5031                }
5032                @Override public int getRuleIndex() { return RULE_bodyTagClose; }
5033                @Override
5034                public void enterRule(ParseTreeListener listener) {
5035                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this);
5036                }
5037                @Override
5038                public void exitRule(ParseTreeListener listener) {
5039                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this);
5040                }
5041                @Override
5042                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5043                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this);
5044                        else return visitor.visitChildren(this);
5045                }
5046        }
5047
5048        public final BodyTagCloseContext bodyTagClose() throws RecognitionException {
5049                BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState());
5050                enterRule(_localctx, 44, RULE_bodyTagClose);
5051                int _la;
5052                try {
5053                        enterOuterAlt(_localctx, 1);
5054                        {
5055                        setState(664);
5056                        match(OPEN);
5057                        setState(665);
5058                        match(SLASH);
5059                        setState(666);
5060                        match(BODY_HTML_TAG_NAME);
5061                        setState(670);
5062                        _errHandler.sync(this);
5063                        _la = _input.LA(1);
5064                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5065                                {
5066                                {
5067                                setState(667);
5068                                _la = _input.LA(1);
5069                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5070                                _errHandler.recoverInline(this);
5071                                }
5072                                else {
5073                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
5074                                        _errHandler.reportMatch(this);
5075                                        consume();
5076                                }
5077                                }
5078                                }
5079                                setState(672);
5080                                _errHandler.sync(this);
5081                                _la = _input.LA(1);
5082                        }
5083                        setState(673);
5084                        match(CLOSE);
5085                        }
5086                }
5087                catch (RecognitionException re) {
5088                        _localctx.exception = re;
5089                        _errHandler.reportError(this, re);
5090                        _errHandler.recover(this, re);
5091                }
5092                finally {
5093                        exitRule();
5094                }
5095                return _localctx;
5096        }
5097
5098        public static class BodyContext extends ParserRuleContext {
5099                public BodyTagOpenContext bodyTagOpen() {
5100                        return getRuleContext(BodyTagOpenContext.class,0);
5101                }
5102                public BodyTagCloseContext bodyTagClose() {
5103                        return getRuleContext(BodyTagCloseContext.class,0);
5104                }
5105                public List<HtmlTagContext> htmlTag() {
5106                        return getRuleContexts(HtmlTagContext.class);
5107                }
5108                public HtmlTagContext htmlTag(int i) {
5109                        return getRuleContext(HtmlTagContext.class,i);
5110                }
5111                public List<SingletonTagContext> singletonTag() {
5112                        return getRuleContexts(SingletonTagContext.class);
5113                }
5114                public SingletonTagContext singletonTag(int i) {
5115                        return getRuleContext(SingletonTagContext.class,i);
5116                }
5117                public List<ParagraphContext> paragraph() {
5118                        return getRuleContexts(ParagraphContext.class);
5119                }
5120                public ParagraphContext paragraph(int i) {
5121                        return getRuleContext(ParagraphContext.class,i);
5122                }
5123                public List<LiContext> li() {
5124                        return getRuleContexts(LiContext.class);
5125                }
5126                public LiContext li(int i) {
5127                        return getRuleContext(LiContext.class,i);
5128                }
5129                public List<TrContext> tr() {
5130                        return getRuleContexts(TrContext.class);
5131                }
5132                public TrContext tr(int i) {
5133                        return getRuleContext(TrContext.class,i);
5134                }
5135                public List<TdContext> td() {
5136                        return getRuleContexts(TdContext.class);
5137                }
5138                public TdContext td(int i) {
5139                        return getRuleContext(TdContext.class,i);
5140                }
5141                public List<ThContext> th() {
5142                        return getRuleContexts(ThContext.class);
5143                }
5144                public ThContext th(int i) {
5145                        return getRuleContext(ThContext.class,i);
5146                }
5147                public List<ColgroupContext> colgroup() {
5148                        return getRuleContexts(ColgroupContext.class);
5149                }
5150                public ColgroupContext colgroup(int i) {
5151                        return getRuleContext(ColgroupContext.class,i);
5152                }
5153                public List<DdContext> dd() {
5154                        return getRuleContexts(DdContext.class);
5155                }
5156                public DdContext dd(int i) {
5157                        return getRuleContext(DdContext.class,i);
5158                }
5159                public List<DtContext> dt() {
5160                        return getRuleContexts(DtContext.class);
5161                }
5162                public DtContext dt(int i) {
5163                        return getRuleContext(DtContext.class,i);
5164                }
5165                public List<HeadContext> head() {
5166                        return getRuleContexts(HeadContext.class);
5167                }
5168                public HeadContext head(int i) {
5169                        return getRuleContext(HeadContext.class,i);
5170                }
5171                public List<HtmlContext> html() {
5172                        return getRuleContexts(HtmlContext.class);
5173                }
5174                public HtmlContext html(int i) {
5175                        return getRuleContext(HtmlContext.class,i);
5176                }
5177                public List<OptionContext> option() {
5178                        return getRuleContexts(OptionContext.class);
5179                }
5180                public OptionContext option(int i) {
5181                        return getRuleContext(OptionContext.class,i);
5182                }
5183                public List<TbodyContext> tbody() {
5184                        return getRuleContexts(TbodyContext.class);
5185                }
5186                public TbodyContext tbody(int i) {
5187                        return getRuleContext(TbodyContext.class,i);
5188                }
5189                public List<TheadContext> thead() {
5190                        return getRuleContexts(TheadContext.class);
5191                }
5192                public TheadContext thead(int i) {
5193                        return getRuleContext(TheadContext.class,i);
5194                }
5195                public List<TfootContext> tfoot() {
5196                        return getRuleContexts(TfootContext.class);
5197                }
5198                public TfootContext tfoot(int i) {
5199                        return getRuleContext(TfootContext.class,i);
5200                }
5201                public List<PTagOpenContext> pTagOpen() {
5202                        return getRuleContexts(PTagOpenContext.class);
5203                }
5204                public PTagOpenContext pTagOpen(int i) {
5205                        return getRuleContext(PTagOpenContext.class,i);
5206                }
5207                public List<LiTagOpenContext> liTagOpen() {
5208                        return getRuleContexts(LiTagOpenContext.class);
5209                }
5210                public LiTagOpenContext liTagOpen(int i) {
5211                        return getRuleContext(LiTagOpenContext.class,i);
5212                }
5213                public List<TrTagOpenContext> trTagOpen() {
5214                        return getRuleContexts(TrTagOpenContext.class);
5215                }
5216                public TrTagOpenContext trTagOpen(int i) {
5217                        return getRuleContext(TrTagOpenContext.class,i);
5218                }
5219                public List<TdTagOpenContext> tdTagOpen() {
5220                        return getRuleContexts(TdTagOpenContext.class);
5221                }
5222                public TdTagOpenContext tdTagOpen(int i) {
5223                        return getRuleContext(TdTagOpenContext.class,i);
5224                }
5225                public List<ThTagOpenContext> thTagOpen() {
5226                        return getRuleContexts(ThTagOpenContext.class);
5227                }
5228                public ThTagOpenContext thTagOpen(int i) {
5229                        return getRuleContext(ThTagOpenContext.class,i);
5230                }
5231                public List<ColgroupTagOpenContext> colgroupTagOpen() {
5232                        return getRuleContexts(ColgroupTagOpenContext.class);
5233                }
5234                public ColgroupTagOpenContext colgroupTagOpen(int i) {
5235                        return getRuleContext(ColgroupTagOpenContext.class,i);
5236                }
5237                public List<DdTagOpenContext> ddTagOpen() {
5238                        return getRuleContexts(DdTagOpenContext.class);
5239                }
5240                public DdTagOpenContext ddTagOpen(int i) {
5241                        return getRuleContext(DdTagOpenContext.class,i);
5242                }
5243                public List<DtTagOpenContext> dtTagOpen() {
5244                        return getRuleContexts(DtTagOpenContext.class);
5245                }
5246                public DtTagOpenContext dtTagOpen(int i) {
5247                        return getRuleContext(DtTagOpenContext.class,i);
5248                }
5249                public List<HeadTagOpenContext> headTagOpen() {
5250                        return getRuleContexts(HeadTagOpenContext.class);
5251                }
5252                public HeadTagOpenContext headTagOpen(int i) {
5253                        return getRuleContext(HeadTagOpenContext.class,i);
5254                }
5255                public List<HtmlTagOpenContext> htmlTagOpen() {
5256                        return getRuleContexts(HtmlTagOpenContext.class);
5257                }
5258                public HtmlTagOpenContext htmlTagOpen(int i) {
5259                        return getRuleContext(HtmlTagOpenContext.class,i);
5260                }
5261                public List<OptionTagOpenContext> optionTagOpen() {
5262                        return getRuleContexts(OptionTagOpenContext.class);
5263                }
5264                public OptionTagOpenContext optionTagOpen(int i) {
5265                        return getRuleContext(OptionTagOpenContext.class,i);
5266                }
5267                public List<TbodyTagOpenContext> tbodyTagOpen() {
5268                        return getRuleContexts(TbodyTagOpenContext.class);
5269                }
5270                public TbodyTagOpenContext tbodyTagOpen(int i) {
5271                        return getRuleContext(TbodyTagOpenContext.class,i);
5272                }
5273                public List<TheadTagOpenContext> theadTagOpen() {
5274                        return getRuleContexts(TheadTagOpenContext.class);
5275                }
5276                public TheadTagOpenContext theadTagOpen(int i) {
5277                        return getRuleContext(TheadTagOpenContext.class,i);
5278                }
5279                public List<TfootTagOpenContext> tfootTagOpen() {
5280                        return getRuleContexts(TfootTagOpenContext.class);
5281                }
5282                public TfootTagOpenContext tfootTagOpen(int i) {
5283                        return getRuleContext(TfootTagOpenContext.class,i);
5284                }
5285                public List<HtmlCommentContext> htmlComment() {
5286                        return getRuleContexts(HtmlCommentContext.class);
5287                }
5288                public HtmlCommentContext htmlComment(int i) {
5289                        return getRuleContext(HtmlCommentContext.class,i);
5290                }
5291                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5292                public TerminalNode CDATA(int i) {
5293                        return getToken(JavadocParser.CDATA, i);
5294                }
5295                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5296                public TerminalNode NEWLINE(int i) {
5297                        return getToken(JavadocParser.NEWLINE, i);
5298                }
5299                public List<TextContext> text() {
5300                        return getRuleContexts(TextContext.class);
5301                }
5302                public TextContext text(int i) {
5303                        return getRuleContext(TextContext.class,i);
5304                }
5305                public List<JavadocInlineTagContext> javadocInlineTag() {
5306                        return getRuleContexts(JavadocInlineTagContext.class);
5307                }
5308                public JavadocInlineTagContext javadocInlineTag(int i) {
5309                        return getRuleContext(JavadocInlineTagContext.class,i);
5310                }
5311                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5312                public TerminalNode LEADING_ASTERISK(int i) {
5313                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5314                }
5315                public BodyContext(ParserRuleContext parent, int invokingState) {
5316                        super(parent, invokingState);
5317                }
5318                @Override public int getRuleIndex() { return RULE_body; }
5319                @Override
5320                public void enterRule(ParseTreeListener listener) {
5321                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this);
5322                }
5323                @Override
5324                public void exitRule(ParseTreeListener listener) {
5325                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this);
5326                }
5327                @Override
5328                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5329                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this);
5330                        else return visitor.visitChildren(this);
5331                }
5332        }
5333
5334        public final BodyContext body() throws RecognitionException {
5335                BodyContext _localctx = new BodyContext(_ctx, getState());
5336                enterRule(_localctx, 46, RULE_body);
5337                try {
5338                        int _alt;
5339                        enterOuterAlt(_localctx, 1);
5340                        {
5341                        setState(675);
5342                        bodyTagOpen();
5343                        setState(715);
5344                        _errHandler.sync(this);
5345                        _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5346                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5347                                if ( _alt==1 ) {
5348                                        {
5349                                        setState(713);
5350                                        _errHandler.sync(this);
5351                                        switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
5352                                        case 1:
5353                                                {
5354                                                setState(676);
5355                                                htmlTag();
5356                                                }
5357                                                break;
5358                                        case 2:
5359                                                {
5360                                                setState(677);
5361                                                singletonTag();
5362                                                }
5363                                                break;
5364                                        case 3:
5365                                                {
5366                                                setState(678);
5367                                                paragraph();
5368                                                }
5369                                                break;
5370                                        case 4:
5371                                                {
5372                                                setState(679);
5373                                                li();
5374                                                }
5375                                                break;
5376                                        case 5:
5377                                                {
5378                                                setState(680);
5379                                                tr();
5380                                                }
5381                                                break;
5382                                        case 6:
5383                                                {
5384                                                setState(681);
5385                                                td();
5386                                                }
5387                                                break;
5388                                        case 7:
5389                                                {
5390                                                setState(682);
5391                                                th();
5392                                                }
5393                                                break;
5394                                        case 8:
5395                                                {
5396                                                setState(683);
5397                                                colgroup();
5398                                                }
5399                                                break;
5400                                        case 9:
5401                                                {
5402                                                setState(684);
5403                                                dd();
5404                                                }
5405                                                break;
5406                                        case 10:
5407                                                {
5408                                                setState(685);
5409                                                dt();
5410                                                }
5411                                                break;
5412                                        case 11:
5413                                                {
5414                                                setState(686);
5415                                                head();
5416                                                }
5417                                                break;
5418                                        case 12:
5419                                                {
5420                                                setState(687);
5421                                                html();
5422                                                }
5423                                                break;
5424                                        case 13:
5425                                                {
5426                                                setState(688);
5427                                                option();
5428                                                }
5429                                                break;
5430                                        case 14:
5431                                                {
5432                                                setState(689);
5433                                                tbody();
5434                                                }
5435                                                break;
5436                                        case 15:
5437                                                {
5438                                                setState(690);
5439                                                thead();
5440                                                }
5441                                                break;
5442                                        case 16:
5443                                                {
5444                                                setState(691);
5445                                                tfoot();
5446                                                }
5447                                                break;
5448                                        case 17:
5449                                                {
5450                                                setState(692);
5451                                                pTagOpen();
5452                                                }
5453                                                break;
5454                                        case 18:
5455                                                {
5456                                                setState(693);
5457                                                liTagOpen();
5458                                                }
5459                                                break;
5460                                        case 19:
5461                                                {
5462                                                setState(694);
5463                                                trTagOpen();
5464                                                }
5465                                                break;
5466                                        case 20:
5467                                                {
5468                                                setState(695);
5469                                                tdTagOpen();
5470                                                }
5471                                                break;
5472                                        case 21:
5473                                                {
5474                                                setState(696);
5475                                                thTagOpen();
5476                                                }
5477                                                break;
5478                                        case 22:
5479                                                {
5480                                                setState(697);
5481                                                colgroupTagOpen();
5482                                                }
5483                                                break;
5484                                        case 23:
5485                                                {
5486                                                setState(698);
5487                                                ddTagOpen();
5488                                                }
5489                                                break;
5490                                        case 24:
5491                                                {
5492                                                setState(699);
5493                                                dtTagOpen();
5494                                                }
5495                                                break;
5496                                        case 25:
5497                                                {
5498                                                setState(700);
5499                                                headTagOpen();
5500                                                }
5501                                                break;
5502                                        case 26:
5503                                                {
5504                                                setState(701);
5505                                                htmlTagOpen();
5506                                                }
5507                                                break;
5508                                        case 27:
5509                                                {
5510                                                setState(702);
5511                                                optionTagOpen();
5512                                                }
5513                                                break;
5514                                        case 28:
5515                                                {
5516                                                setState(703);
5517                                                tbodyTagOpen();
5518                                                }
5519                                                break;
5520                                        case 29:
5521                                                {
5522                                                setState(704);
5523                                                theadTagOpen();
5524                                                }
5525                                                break;
5526                                        case 30:
5527                                                {
5528                                                setState(705);
5529                                                tfootTagOpen();
5530                                                }
5531                                                break;
5532                                        case 31:
5533                                                {
5534                                                {
5535                                                setState(706);
5536                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5537                                                setState(707);
5538                                                match(LEADING_ASTERISK);
5539                                                }
5540                                                }
5541                                                break;
5542                                        case 32:
5543                                                {
5544                                                setState(708);
5545                                                htmlComment();
5546                                                }
5547                                                break;
5548                                        case 33:
5549                                                {
5550                                                setState(709);
5551                                                match(CDATA);
5552                                                }
5553                                                break;
5554                                        case 34:
5555                                                {
5556                                                setState(710);
5557                                                match(NEWLINE);
5558                                                }
5559                                                break;
5560                                        case 35:
5561                                                {
5562                                                setState(711);
5563                                                text();
5564                                                }
5565                                                break;
5566                                        case 36:
5567                                                {
5568                                                setState(712);
5569                                                javadocInlineTag();
5570                                                }
5571                                                break;
5572                                        }
5573                                        } 
5574                                }
5575                                setState(717);
5576                                _errHandler.sync(this);
5577                                _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5578                        }
5579                        setState(718);
5580                        bodyTagClose();
5581                        }
5582                }
5583                catch (RecognitionException re) {
5584                        _localctx.exception = re;
5585                        _errHandler.reportError(this, re);
5586                        _errHandler.recover(this, re);
5587                }
5588                finally {
5589                        exitRule();
5590                }
5591                return _localctx;
5592        }
5593
5594        public static class ColgroupTagOpenContext extends ParserRuleContext {
5595                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5596                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5597                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5598                public List<AttributeContext> attribute() {
5599                        return getRuleContexts(AttributeContext.class);
5600                }
5601                public AttributeContext attribute(int i) {
5602                        return getRuleContext(AttributeContext.class,i);
5603                }
5604                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5605                public TerminalNode NEWLINE(int i) {
5606                        return getToken(JavadocParser.NEWLINE, i);
5607                }
5608                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5609                public TerminalNode LEADING_ASTERISK(int i) {
5610                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5611                }
5612                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5613                public TerminalNode WS(int i) {
5614                        return getToken(JavadocParser.WS, i);
5615                }
5616                public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) {
5617                        super(parent, invokingState);
5618                }
5619                @Override public int getRuleIndex() { return RULE_colgroupTagOpen; }
5620                @Override
5621                public void enterRule(ParseTreeListener listener) {
5622                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this);
5623                }
5624                @Override
5625                public void exitRule(ParseTreeListener listener) {
5626                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this);
5627                }
5628                @Override
5629                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5630                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this);
5631                        else return visitor.visitChildren(this);
5632                }
5633        }
5634
5635        public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException {
5636                ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState());
5637                enterRule(_localctx, 48, RULE_colgroupTagOpen);
5638                int _la;
5639                try {
5640                        enterOuterAlt(_localctx, 1);
5641                        {
5642                        setState(720);
5643                        match(OPEN);
5644                        setState(721);
5645                        match(COLGROUP_HTML_TAG_NAME);
5646                        setState(728);
5647                        _errHandler.sync(this);
5648                        _la = _input.LA(1);
5649                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5650                                {
5651                                setState(726);
5652                                _errHandler.sync(this);
5653                                switch (_input.LA(1)) {
5654                                case HTML_TAG_NAME:
5655                                        {
5656                                        setState(722);
5657                                        attribute();
5658                                        }
5659                                        break;
5660                                case NEWLINE:
5661                                        {
5662                                        setState(723);
5663                                        match(NEWLINE);
5664                                        }
5665                                        break;
5666                                case LEADING_ASTERISK:
5667                                        {
5668                                        setState(724);
5669                                        match(LEADING_ASTERISK);
5670                                        }
5671                                        break;
5672                                case WS:
5673                                        {
5674                                        setState(725);
5675                                        match(WS);
5676                                        }
5677                                        break;
5678                                default:
5679                                        throw new NoViableAltException(this);
5680                                }
5681                                }
5682                                setState(730);
5683                                _errHandler.sync(this);
5684                                _la = _input.LA(1);
5685                        }
5686                        setState(731);
5687                        match(CLOSE);
5688                        }
5689                }
5690                catch (RecognitionException re) {
5691                        _localctx.exception = re;
5692                        _errHandler.reportError(this, re);
5693                        _errHandler.recover(this, re);
5694                }
5695                finally {
5696                        exitRule();
5697                }
5698                return _localctx;
5699        }
5700
5701        public static class ColgroupTagCloseContext extends ParserRuleContext {
5702                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5703                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5704                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5705                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5706                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5707                public TerminalNode NEWLINE(int i) {
5708                        return getToken(JavadocParser.NEWLINE, i);
5709                }
5710                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5711                public TerminalNode LEADING_ASTERISK(int i) {
5712                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5713                }
5714                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5715                public TerminalNode WS(int i) {
5716                        return getToken(JavadocParser.WS, i);
5717                }
5718                public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) {
5719                        super(parent, invokingState);
5720                }
5721                @Override public int getRuleIndex() { return RULE_colgroupTagClose; }
5722                @Override
5723                public void enterRule(ParseTreeListener listener) {
5724                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this);
5725                }
5726                @Override
5727                public void exitRule(ParseTreeListener listener) {
5728                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this);
5729                }
5730                @Override
5731                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5732                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this);
5733                        else return visitor.visitChildren(this);
5734                }
5735        }
5736
5737        public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException {
5738                ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState());
5739                enterRule(_localctx, 50, RULE_colgroupTagClose);
5740                int _la;
5741                try {
5742                        enterOuterAlt(_localctx, 1);
5743                        {
5744                        setState(733);
5745                        match(OPEN);
5746                        setState(734);
5747                        match(SLASH);
5748                        setState(735);
5749                        match(COLGROUP_HTML_TAG_NAME);
5750                        setState(739);
5751                        _errHandler.sync(this);
5752                        _la = _input.LA(1);
5753                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5754                                {
5755                                {
5756                                setState(736);
5757                                _la = _input.LA(1);
5758                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5759                                _errHandler.recoverInline(this);
5760                                }
5761                                else {
5762                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
5763                                        _errHandler.reportMatch(this);
5764                                        consume();
5765                                }
5766                                }
5767                                }
5768                                setState(741);
5769                                _errHandler.sync(this);
5770                                _la = _input.LA(1);
5771                        }
5772                        setState(742);
5773                        match(CLOSE);
5774                        }
5775                }
5776                catch (RecognitionException re) {
5777                        _localctx.exception = re;
5778                        _errHandler.reportError(this, re);
5779                        _errHandler.recover(this, re);
5780                }
5781                finally {
5782                        exitRule();
5783                }
5784                return _localctx;
5785        }
5786
5787        public static class ColgroupContext extends ParserRuleContext {
5788                public ColgroupTagOpenContext colgroupTagOpen() {
5789                        return getRuleContext(ColgroupTagOpenContext.class,0);
5790                }
5791                public ColgroupTagCloseContext colgroupTagClose() {
5792                        return getRuleContext(ColgroupTagCloseContext.class,0);
5793                }
5794                public List<HtmlTagContext> htmlTag() {
5795                        return getRuleContexts(HtmlTagContext.class);
5796                }
5797                public HtmlTagContext htmlTag(int i) {
5798                        return getRuleContext(HtmlTagContext.class,i);
5799                }
5800                public List<SingletonTagContext> singletonTag() {
5801                        return getRuleContexts(SingletonTagContext.class);
5802                }
5803                public SingletonTagContext singletonTag(int i) {
5804                        return getRuleContext(SingletonTagContext.class,i);
5805                }
5806                public List<ParagraphContext> paragraph() {
5807                        return getRuleContexts(ParagraphContext.class);
5808                }
5809                public ParagraphContext paragraph(int i) {
5810                        return getRuleContext(ParagraphContext.class,i);
5811                }
5812                public List<LiContext> li() {
5813                        return getRuleContexts(LiContext.class);
5814                }
5815                public LiContext li(int i) {
5816                        return getRuleContext(LiContext.class,i);
5817                }
5818                public List<TrContext> tr() {
5819                        return getRuleContexts(TrContext.class);
5820                }
5821                public TrContext tr(int i) {
5822                        return getRuleContext(TrContext.class,i);
5823                }
5824                public List<TdContext> td() {
5825                        return getRuleContexts(TdContext.class);
5826                }
5827                public TdContext td(int i) {
5828                        return getRuleContext(TdContext.class,i);
5829                }
5830                public List<ThContext> th() {
5831                        return getRuleContexts(ThContext.class);
5832                }
5833                public ThContext th(int i) {
5834                        return getRuleContext(ThContext.class,i);
5835                }
5836                public List<BodyContext> body() {
5837                        return getRuleContexts(BodyContext.class);
5838                }
5839                public BodyContext body(int i) {
5840                        return getRuleContext(BodyContext.class,i);
5841                }
5842                public List<DdContext> dd() {
5843                        return getRuleContexts(DdContext.class);
5844                }
5845                public DdContext dd(int i) {
5846                        return getRuleContext(DdContext.class,i);
5847                }
5848                public List<DtContext> dt() {
5849                        return getRuleContexts(DtContext.class);
5850                }
5851                public DtContext dt(int i) {
5852                        return getRuleContext(DtContext.class,i);
5853                }
5854                public List<HeadContext> head() {
5855                        return getRuleContexts(HeadContext.class);
5856                }
5857                public HeadContext head(int i) {
5858                        return getRuleContext(HeadContext.class,i);
5859                }
5860                public List<HtmlContext> html() {
5861                        return getRuleContexts(HtmlContext.class);
5862                }
5863                public HtmlContext html(int i) {
5864                        return getRuleContext(HtmlContext.class,i);
5865                }
5866                public List<OptionContext> option() {
5867                        return getRuleContexts(OptionContext.class);
5868                }
5869                public OptionContext option(int i) {
5870                        return getRuleContext(OptionContext.class,i);
5871                }
5872                public List<TbodyContext> tbody() {
5873                        return getRuleContexts(TbodyContext.class);
5874                }
5875                public TbodyContext tbody(int i) {
5876                        return getRuleContext(TbodyContext.class,i);
5877                }
5878                public List<TheadContext> thead() {
5879                        return getRuleContexts(TheadContext.class);
5880                }
5881                public TheadContext thead(int i) {
5882                        return getRuleContext(TheadContext.class,i);
5883                }
5884                public List<TfootContext> tfoot() {
5885                        return getRuleContexts(TfootContext.class);
5886                }
5887                public TfootContext tfoot(int i) {
5888                        return getRuleContext(TfootContext.class,i);
5889                }
5890                public List<PTagOpenContext> pTagOpen() {
5891                        return getRuleContexts(PTagOpenContext.class);
5892                }
5893                public PTagOpenContext pTagOpen(int i) {
5894                        return getRuleContext(PTagOpenContext.class,i);
5895                }
5896                public List<LiTagOpenContext> liTagOpen() {
5897                        return getRuleContexts(LiTagOpenContext.class);
5898                }
5899                public LiTagOpenContext liTagOpen(int i) {
5900                        return getRuleContext(LiTagOpenContext.class,i);
5901                }
5902                public List<TrTagOpenContext> trTagOpen() {
5903                        return getRuleContexts(TrTagOpenContext.class);
5904                }
5905                public TrTagOpenContext trTagOpen(int i) {
5906                        return getRuleContext(TrTagOpenContext.class,i);
5907                }
5908                public List<TdTagOpenContext> tdTagOpen() {
5909                        return getRuleContexts(TdTagOpenContext.class);
5910                }
5911                public TdTagOpenContext tdTagOpen(int i) {
5912                        return getRuleContext(TdTagOpenContext.class,i);
5913                }
5914                public List<ThTagOpenContext> thTagOpen() {
5915                        return getRuleContexts(ThTagOpenContext.class);
5916                }
5917                public ThTagOpenContext thTagOpen(int i) {
5918                        return getRuleContext(ThTagOpenContext.class,i);
5919                }
5920                public List<BodyTagOpenContext> bodyTagOpen() {
5921                        return getRuleContexts(BodyTagOpenContext.class);
5922                }
5923                public BodyTagOpenContext bodyTagOpen(int i) {
5924                        return getRuleContext(BodyTagOpenContext.class,i);
5925                }
5926                public List<DdTagOpenContext> ddTagOpen() {
5927                        return getRuleContexts(DdTagOpenContext.class);
5928                }
5929                public DdTagOpenContext ddTagOpen(int i) {
5930                        return getRuleContext(DdTagOpenContext.class,i);
5931                }
5932                public List<DtTagOpenContext> dtTagOpen() {
5933                        return getRuleContexts(DtTagOpenContext.class);
5934                }
5935                public DtTagOpenContext dtTagOpen(int i) {
5936                        return getRuleContext(DtTagOpenContext.class,i);
5937                }
5938                public List<HeadTagOpenContext> headTagOpen() {
5939                        return getRuleContexts(HeadTagOpenContext.class);
5940                }
5941                public HeadTagOpenContext headTagOpen(int i) {
5942                        return getRuleContext(HeadTagOpenContext.class,i);
5943                }
5944                public List<HtmlTagOpenContext> htmlTagOpen() {
5945                        return getRuleContexts(HtmlTagOpenContext.class);
5946                }
5947                public HtmlTagOpenContext htmlTagOpen(int i) {
5948                        return getRuleContext(HtmlTagOpenContext.class,i);
5949                }
5950                public List<OptionTagOpenContext> optionTagOpen() {
5951                        return getRuleContexts(OptionTagOpenContext.class);
5952                }
5953                public OptionTagOpenContext optionTagOpen(int i) {
5954                        return getRuleContext(OptionTagOpenContext.class,i);
5955                }
5956                public List<TbodyTagOpenContext> tbodyTagOpen() {
5957                        return getRuleContexts(TbodyTagOpenContext.class);
5958                }
5959                public TbodyTagOpenContext tbodyTagOpen(int i) {
5960                        return getRuleContext(TbodyTagOpenContext.class,i);
5961                }
5962                public List<TheadTagOpenContext> theadTagOpen() {
5963                        return getRuleContexts(TheadTagOpenContext.class);
5964                }
5965                public TheadTagOpenContext theadTagOpen(int i) {
5966                        return getRuleContext(TheadTagOpenContext.class,i);
5967                }
5968                public List<TfootTagOpenContext> tfootTagOpen() {
5969                        return getRuleContexts(TfootTagOpenContext.class);
5970                }
5971                public TfootTagOpenContext tfootTagOpen(int i) {
5972                        return getRuleContext(TfootTagOpenContext.class,i);
5973                }
5974                public List<HtmlCommentContext> htmlComment() {
5975                        return getRuleContexts(HtmlCommentContext.class);
5976                }
5977                public HtmlCommentContext htmlComment(int i) {
5978                        return getRuleContext(HtmlCommentContext.class,i);
5979                }
5980                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5981                public TerminalNode CDATA(int i) {
5982                        return getToken(JavadocParser.CDATA, i);
5983                }
5984                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5985                public TerminalNode NEWLINE(int i) {
5986                        return getToken(JavadocParser.NEWLINE, i);
5987                }
5988                public List<TextContext> text() {
5989                        return getRuleContexts(TextContext.class);
5990                }
5991                public TextContext text(int i) {
5992                        return getRuleContext(TextContext.class,i);
5993                }
5994                public List<JavadocInlineTagContext> javadocInlineTag() {
5995                        return getRuleContexts(JavadocInlineTagContext.class);
5996                }
5997                public JavadocInlineTagContext javadocInlineTag(int i) {
5998                        return getRuleContext(JavadocInlineTagContext.class,i);
5999                }
6000                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6001                public TerminalNode LEADING_ASTERISK(int i) {
6002                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6003                }
6004                public ColgroupContext(ParserRuleContext parent, int invokingState) {
6005                        super(parent, invokingState);
6006                }
6007                @Override public int getRuleIndex() { return RULE_colgroup; }
6008                @Override
6009                public void enterRule(ParseTreeListener listener) {
6010                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this);
6011                }
6012                @Override
6013                public void exitRule(ParseTreeListener listener) {
6014                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this);
6015                }
6016                @Override
6017                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6018                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this);
6019                        else return visitor.visitChildren(this);
6020                }
6021        }
6022
6023        public final ColgroupContext colgroup() throws RecognitionException {
6024                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
6025                enterRule(_localctx, 52, RULE_colgroup);
6026                try {
6027                        int _alt;
6028                        enterOuterAlt(_localctx, 1);
6029                        {
6030                        setState(744);
6031                        colgroupTagOpen();
6032                        setState(784);
6033                        _errHandler.sync(this);
6034                        _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6035                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6036                                if ( _alt==1 ) {
6037                                        {
6038                                        setState(782);
6039                                        _errHandler.sync(this);
6040                                        switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
6041                                        case 1:
6042                                                {
6043                                                setState(745);
6044                                                htmlTag();
6045                                                }
6046                                                break;
6047                                        case 2:
6048                                                {
6049                                                setState(746);
6050                                                singletonTag();
6051                                                }
6052                                                break;
6053                                        case 3:
6054                                                {
6055                                                setState(747);
6056                                                paragraph();
6057                                                }
6058                                                break;
6059                                        case 4:
6060                                                {
6061                                                setState(748);
6062                                                li();
6063                                                }
6064                                                break;
6065                                        case 5:
6066                                                {
6067                                                setState(749);
6068                                                tr();
6069                                                }
6070                                                break;
6071                                        case 6:
6072                                                {
6073                                                setState(750);
6074                                                td();
6075                                                }
6076                                                break;
6077                                        case 7:
6078                                                {
6079                                                setState(751);
6080                                                th();
6081                                                }
6082                                                break;
6083                                        case 8:
6084                                                {
6085                                                setState(752);
6086                                                body();
6087                                                }
6088                                                break;
6089                                        case 9:
6090                                                {
6091                                                setState(753);
6092                                                dd();
6093                                                }
6094                                                break;
6095                                        case 10:
6096                                                {
6097                                                setState(754);
6098                                                dt();
6099                                                }
6100                                                break;
6101                                        case 11:
6102                                                {
6103                                                setState(755);
6104                                                head();
6105                                                }
6106                                                break;
6107                                        case 12:
6108                                                {
6109                                                setState(756);
6110                                                html();
6111                                                }
6112                                                break;
6113                                        case 13:
6114                                                {
6115                                                setState(757);
6116                                                option();
6117                                                }
6118                                                break;
6119                                        case 14:
6120                                                {
6121                                                setState(758);
6122                                                tbody();
6123                                                }
6124                                                break;
6125                                        case 15:
6126                                                {
6127                                                setState(759);
6128                                                thead();
6129                                                }
6130                                                break;
6131                                        case 16:
6132                                                {
6133                                                setState(760);
6134                                                tfoot();
6135                                                }
6136                                                break;
6137                                        case 17:
6138                                                {
6139                                                setState(761);
6140                                                pTagOpen();
6141                                                }
6142                                                break;
6143                                        case 18:
6144                                                {
6145                                                setState(762);
6146                                                liTagOpen();
6147                                                }
6148                                                break;
6149                                        case 19:
6150                                                {
6151                                                setState(763);
6152                                                trTagOpen();
6153                                                }
6154                                                break;
6155                                        case 20:
6156                                                {
6157                                                setState(764);
6158                                                tdTagOpen();
6159                                                }
6160                                                break;
6161                                        case 21:
6162                                                {
6163                                                setState(765);
6164                                                thTagOpen();
6165                                                }
6166                                                break;
6167                                        case 22:
6168                                                {
6169                                                setState(766);
6170                                                bodyTagOpen();
6171                                                }
6172                                                break;
6173                                        case 23:
6174                                                {
6175                                                setState(767);
6176                                                ddTagOpen();
6177                                                }
6178                                                break;
6179                                        case 24:
6180                                                {
6181                                                setState(768);
6182                                                dtTagOpen();
6183                                                }
6184                                                break;
6185                                        case 25:
6186                                                {
6187                                                setState(769);
6188                                                headTagOpen();
6189                                                }
6190                                                break;
6191                                        case 26:
6192                                                {
6193                                                setState(770);
6194                                                htmlTagOpen();
6195                                                }
6196                                                break;
6197                                        case 27:
6198                                                {
6199                                                setState(771);
6200                                                optionTagOpen();
6201                                                }
6202                                                break;
6203                                        case 28:
6204                                                {
6205                                                setState(772);
6206                                                tbodyTagOpen();
6207                                                }
6208                                                break;
6209                                        case 29:
6210                                                {
6211                                                setState(773);
6212                                                theadTagOpen();
6213                                                }
6214                                                break;
6215                                        case 30:
6216                                                {
6217                                                setState(774);
6218                                                tfootTagOpen();
6219                                                }
6220                                                break;
6221                                        case 31:
6222                                                {
6223                                                {
6224                                                setState(775);
6225                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6226                                                setState(776);
6227                                                match(LEADING_ASTERISK);
6228                                                }
6229                                                }
6230                                                break;
6231                                        case 32:
6232                                                {
6233                                                setState(777);
6234                                                htmlComment();
6235                                                }
6236                                                break;
6237                                        case 33:
6238                                                {
6239                                                setState(778);
6240                                                match(CDATA);
6241                                                }
6242                                                break;
6243                                        case 34:
6244                                                {
6245                                                setState(779);
6246                                                match(NEWLINE);
6247                                                }
6248                                                break;
6249                                        case 35:
6250                                                {
6251                                                setState(780);
6252                                                text();
6253                                                }
6254                                                break;
6255                                        case 36:
6256                                                {
6257                                                setState(781);
6258                                                javadocInlineTag();
6259                                                }
6260                                                break;
6261                                        }
6262                                        } 
6263                                }
6264                                setState(786);
6265                                _errHandler.sync(this);
6266                                _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6267                        }
6268                        setState(787);
6269                        colgroupTagClose();
6270                        }
6271                }
6272                catch (RecognitionException re) {
6273                        _localctx.exception = re;
6274                        _errHandler.reportError(this, re);
6275                        _errHandler.recover(this, re);
6276                }
6277                finally {
6278                        exitRule();
6279                }
6280                return _localctx;
6281        }
6282
6283        public static class DdTagOpenContext extends ParserRuleContext {
6284                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6285                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6286                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6287                public List<AttributeContext> attribute() {
6288                        return getRuleContexts(AttributeContext.class);
6289                }
6290                public AttributeContext attribute(int i) {
6291                        return getRuleContext(AttributeContext.class,i);
6292                }
6293                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6294                public TerminalNode NEWLINE(int i) {
6295                        return getToken(JavadocParser.NEWLINE, i);
6296                }
6297                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6298                public TerminalNode LEADING_ASTERISK(int i) {
6299                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6300                }
6301                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6302                public TerminalNode WS(int i) {
6303                        return getToken(JavadocParser.WS, i);
6304                }
6305                public DdTagOpenContext(ParserRuleContext parent, int invokingState) {
6306                        super(parent, invokingState);
6307                }
6308                @Override public int getRuleIndex() { return RULE_ddTagOpen; }
6309                @Override
6310                public void enterRule(ParseTreeListener listener) {
6311                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this);
6312                }
6313                @Override
6314                public void exitRule(ParseTreeListener listener) {
6315                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this);
6316                }
6317                @Override
6318                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6319                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this);
6320                        else return visitor.visitChildren(this);
6321                }
6322        }
6323
6324        public final DdTagOpenContext ddTagOpen() throws RecognitionException {
6325                DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState());
6326                enterRule(_localctx, 54, RULE_ddTagOpen);
6327                int _la;
6328                try {
6329                        enterOuterAlt(_localctx, 1);
6330                        {
6331                        setState(789);
6332                        match(OPEN);
6333                        setState(790);
6334                        match(DD_HTML_TAG_NAME);
6335                        setState(797);
6336                        _errHandler.sync(this);
6337                        _la = _input.LA(1);
6338                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6339                                {
6340                                setState(795);
6341                                _errHandler.sync(this);
6342                                switch (_input.LA(1)) {
6343                                case HTML_TAG_NAME:
6344                                        {
6345                                        setState(791);
6346                                        attribute();
6347                                        }
6348                                        break;
6349                                case NEWLINE:
6350                                        {
6351                                        setState(792);
6352                                        match(NEWLINE);
6353                                        }
6354                                        break;
6355                                case LEADING_ASTERISK:
6356                                        {
6357                                        setState(793);
6358                                        match(LEADING_ASTERISK);
6359                                        }
6360                                        break;
6361                                case WS:
6362                                        {
6363                                        setState(794);
6364                                        match(WS);
6365                                        }
6366                                        break;
6367                                default:
6368                                        throw new NoViableAltException(this);
6369                                }
6370                                }
6371                                setState(799);
6372                                _errHandler.sync(this);
6373                                _la = _input.LA(1);
6374                        }
6375                        setState(800);
6376                        match(CLOSE);
6377                        }
6378                }
6379                catch (RecognitionException re) {
6380                        _localctx.exception = re;
6381                        _errHandler.reportError(this, re);
6382                        _errHandler.recover(this, re);
6383                }
6384                finally {
6385                        exitRule();
6386                }
6387                return _localctx;
6388        }
6389
6390        public static class DdTagCloseContext extends ParserRuleContext {
6391                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6392                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6393                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6394                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6395                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6396                public TerminalNode NEWLINE(int i) {
6397                        return getToken(JavadocParser.NEWLINE, i);
6398                }
6399                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6400                public TerminalNode LEADING_ASTERISK(int i) {
6401                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6402                }
6403                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6404                public TerminalNode WS(int i) {
6405                        return getToken(JavadocParser.WS, i);
6406                }
6407                public DdTagCloseContext(ParserRuleContext parent, int invokingState) {
6408                        super(parent, invokingState);
6409                }
6410                @Override public int getRuleIndex() { return RULE_ddTagClose; }
6411                @Override
6412                public void enterRule(ParseTreeListener listener) {
6413                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this);
6414                }
6415                @Override
6416                public void exitRule(ParseTreeListener listener) {
6417                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this);
6418                }
6419                @Override
6420                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6421                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this);
6422                        else return visitor.visitChildren(this);
6423                }
6424        }
6425
6426        public final DdTagCloseContext ddTagClose() throws RecognitionException {
6427                DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState());
6428                enterRule(_localctx, 56, RULE_ddTagClose);
6429                int _la;
6430                try {
6431                        enterOuterAlt(_localctx, 1);
6432                        {
6433                        setState(802);
6434                        match(OPEN);
6435                        setState(803);
6436                        match(SLASH);
6437                        setState(804);
6438                        match(DD_HTML_TAG_NAME);
6439                        setState(808);
6440                        _errHandler.sync(this);
6441                        _la = _input.LA(1);
6442                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6443                                {
6444                                {
6445                                setState(805);
6446                                _la = _input.LA(1);
6447                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6448                                _errHandler.recoverInline(this);
6449                                }
6450                                else {
6451                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
6452                                        _errHandler.reportMatch(this);
6453                                        consume();
6454                                }
6455                                }
6456                                }
6457                                setState(810);
6458                                _errHandler.sync(this);
6459                                _la = _input.LA(1);
6460                        }
6461                        setState(811);
6462                        match(CLOSE);
6463                        }
6464                }
6465                catch (RecognitionException re) {
6466                        _localctx.exception = re;
6467                        _errHandler.reportError(this, re);
6468                        _errHandler.recover(this, re);
6469                }
6470                finally {
6471                        exitRule();
6472                }
6473                return _localctx;
6474        }
6475
6476        public static class DdContext extends ParserRuleContext {
6477                public DdTagOpenContext ddTagOpen() {
6478                        return getRuleContext(DdTagOpenContext.class,0);
6479                }
6480                public DdTagCloseContext ddTagClose() {
6481                        return getRuleContext(DdTagCloseContext.class,0);
6482                }
6483                public List<HtmlTagContext> htmlTag() {
6484                        return getRuleContexts(HtmlTagContext.class);
6485                }
6486                public HtmlTagContext htmlTag(int i) {
6487                        return getRuleContext(HtmlTagContext.class,i);
6488                }
6489                public List<SingletonTagContext> singletonTag() {
6490                        return getRuleContexts(SingletonTagContext.class);
6491                }
6492                public SingletonTagContext singletonTag(int i) {
6493                        return getRuleContext(SingletonTagContext.class,i);
6494                }
6495                public List<ParagraphContext> paragraph() {
6496                        return getRuleContexts(ParagraphContext.class);
6497                }
6498                public ParagraphContext paragraph(int i) {
6499                        return getRuleContext(ParagraphContext.class,i);
6500                }
6501                public List<LiContext> li() {
6502                        return getRuleContexts(LiContext.class);
6503                }
6504                public LiContext li(int i) {
6505                        return getRuleContext(LiContext.class,i);
6506                }
6507                public List<TrContext> tr() {
6508                        return getRuleContexts(TrContext.class);
6509                }
6510                public TrContext tr(int i) {
6511                        return getRuleContext(TrContext.class,i);
6512                }
6513                public List<TdContext> td() {
6514                        return getRuleContexts(TdContext.class);
6515                }
6516                public TdContext td(int i) {
6517                        return getRuleContext(TdContext.class,i);
6518                }
6519                public List<ThContext> th() {
6520                        return getRuleContexts(ThContext.class);
6521                }
6522                public ThContext th(int i) {
6523                        return getRuleContext(ThContext.class,i);
6524                }
6525                public List<BodyContext> body() {
6526                        return getRuleContexts(BodyContext.class);
6527                }
6528                public BodyContext body(int i) {
6529                        return getRuleContext(BodyContext.class,i);
6530                }
6531                public List<ColgroupContext> colgroup() {
6532                        return getRuleContexts(ColgroupContext.class);
6533                }
6534                public ColgroupContext colgroup(int i) {
6535                        return getRuleContext(ColgroupContext.class,i);
6536                }
6537                public List<DtContext> dt() {
6538                        return getRuleContexts(DtContext.class);
6539                }
6540                public DtContext dt(int i) {
6541                        return getRuleContext(DtContext.class,i);
6542                }
6543                public List<HeadContext> head() {
6544                        return getRuleContexts(HeadContext.class);
6545                }
6546                public HeadContext head(int i) {
6547                        return getRuleContext(HeadContext.class,i);
6548                }
6549                public List<HtmlContext> html() {
6550                        return getRuleContexts(HtmlContext.class);
6551                }
6552                public HtmlContext html(int i) {
6553                        return getRuleContext(HtmlContext.class,i);
6554                }
6555                public List<OptionContext> option() {
6556                        return getRuleContexts(OptionContext.class);
6557                }
6558                public OptionContext option(int i) {
6559                        return getRuleContext(OptionContext.class,i);
6560                }
6561                public List<TbodyContext> tbody() {
6562                        return getRuleContexts(TbodyContext.class);
6563                }
6564                public TbodyContext tbody(int i) {
6565                        return getRuleContext(TbodyContext.class,i);
6566                }
6567                public List<TheadContext> thead() {
6568                        return getRuleContexts(TheadContext.class);
6569                }
6570                public TheadContext thead(int i) {
6571                        return getRuleContext(TheadContext.class,i);
6572                }
6573                public List<TfootContext> tfoot() {
6574                        return getRuleContexts(TfootContext.class);
6575                }
6576                public TfootContext tfoot(int i) {
6577                        return getRuleContext(TfootContext.class,i);
6578                }
6579                public List<PTagOpenContext> pTagOpen() {
6580                        return getRuleContexts(PTagOpenContext.class);
6581                }
6582                public PTagOpenContext pTagOpen(int i) {
6583                        return getRuleContext(PTagOpenContext.class,i);
6584                }
6585                public List<LiTagOpenContext> liTagOpen() {
6586                        return getRuleContexts(LiTagOpenContext.class);
6587                }
6588                public LiTagOpenContext liTagOpen(int i) {
6589                        return getRuleContext(LiTagOpenContext.class,i);
6590                }
6591                public List<TrTagOpenContext> trTagOpen() {
6592                        return getRuleContexts(TrTagOpenContext.class);
6593                }
6594                public TrTagOpenContext trTagOpen(int i) {
6595                        return getRuleContext(TrTagOpenContext.class,i);
6596                }
6597                public List<TdTagOpenContext> tdTagOpen() {
6598                        return getRuleContexts(TdTagOpenContext.class);
6599                }
6600                public TdTagOpenContext tdTagOpen(int i) {
6601                        return getRuleContext(TdTagOpenContext.class,i);
6602                }
6603                public List<ThTagOpenContext> thTagOpen() {
6604                        return getRuleContexts(ThTagOpenContext.class);
6605                }
6606                public ThTagOpenContext thTagOpen(int i) {
6607                        return getRuleContext(ThTagOpenContext.class,i);
6608                }
6609                public List<BodyTagOpenContext> bodyTagOpen() {
6610                        return getRuleContexts(BodyTagOpenContext.class);
6611                }
6612                public BodyTagOpenContext bodyTagOpen(int i) {
6613                        return getRuleContext(BodyTagOpenContext.class,i);
6614                }
6615                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6616                        return getRuleContexts(ColgroupTagOpenContext.class);
6617                }
6618                public ColgroupTagOpenContext colgroupTagOpen(int i) {
6619                        return getRuleContext(ColgroupTagOpenContext.class,i);
6620                }
6621                public List<DtTagOpenContext> dtTagOpen() {
6622                        return getRuleContexts(DtTagOpenContext.class);
6623                }
6624                public DtTagOpenContext dtTagOpen(int i) {
6625                        return getRuleContext(DtTagOpenContext.class,i);
6626                }
6627                public List<HeadTagOpenContext> headTagOpen() {
6628                        return getRuleContexts(HeadTagOpenContext.class);
6629                }
6630                public HeadTagOpenContext headTagOpen(int i) {
6631                        return getRuleContext(HeadTagOpenContext.class,i);
6632                }
6633                public List<HtmlTagOpenContext> htmlTagOpen() {
6634                        return getRuleContexts(HtmlTagOpenContext.class);
6635                }
6636                public HtmlTagOpenContext htmlTagOpen(int i) {
6637                        return getRuleContext(HtmlTagOpenContext.class,i);
6638                }
6639                public List<OptionTagOpenContext> optionTagOpen() {
6640                        return getRuleContexts(OptionTagOpenContext.class);
6641                }
6642                public OptionTagOpenContext optionTagOpen(int i) {
6643                        return getRuleContext(OptionTagOpenContext.class,i);
6644                }
6645                public List<TbodyTagOpenContext> tbodyTagOpen() {
6646                        return getRuleContexts(TbodyTagOpenContext.class);
6647                }
6648                public TbodyTagOpenContext tbodyTagOpen(int i) {
6649                        return getRuleContext(TbodyTagOpenContext.class,i);
6650                }
6651                public List<TheadTagOpenContext> theadTagOpen() {
6652                        return getRuleContexts(TheadTagOpenContext.class);
6653                }
6654                public TheadTagOpenContext theadTagOpen(int i) {
6655                        return getRuleContext(TheadTagOpenContext.class,i);
6656                }
6657                public List<TfootTagOpenContext> tfootTagOpen() {
6658                        return getRuleContexts(TfootTagOpenContext.class);
6659                }
6660                public TfootTagOpenContext tfootTagOpen(int i) {
6661                        return getRuleContext(TfootTagOpenContext.class,i);
6662                }
6663                public List<HtmlCommentContext> htmlComment() {
6664                        return getRuleContexts(HtmlCommentContext.class);
6665                }
6666                public HtmlCommentContext htmlComment(int i) {
6667                        return getRuleContext(HtmlCommentContext.class,i);
6668                }
6669                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6670                public TerminalNode CDATA(int i) {
6671                        return getToken(JavadocParser.CDATA, i);
6672                }
6673                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6674                public TerminalNode NEWLINE(int i) {
6675                        return getToken(JavadocParser.NEWLINE, i);
6676                }
6677                public List<TextContext> text() {
6678                        return getRuleContexts(TextContext.class);
6679                }
6680                public TextContext text(int i) {
6681                        return getRuleContext(TextContext.class,i);
6682                }
6683                public List<JavadocInlineTagContext> javadocInlineTag() {
6684                        return getRuleContexts(JavadocInlineTagContext.class);
6685                }
6686                public JavadocInlineTagContext javadocInlineTag(int i) {
6687                        return getRuleContext(JavadocInlineTagContext.class,i);
6688                }
6689                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6690                public TerminalNode LEADING_ASTERISK(int i) {
6691                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6692                }
6693                public DdContext(ParserRuleContext parent, int invokingState) {
6694                        super(parent, invokingState);
6695                }
6696                @Override public int getRuleIndex() { return RULE_dd; }
6697                @Override
6698                public void enterRule(ParseTreeListener listener) {
6699                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this);
6700                }
6701                @Override
6702                public void exitRule(ParseTreeListener listener) {
6703                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this);
6704                }
6705                @Override
6706                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6707                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this);
6708                        else return visitor.visitChildren(this);
6709                }
6710        }
6711
6712        public final DdContext dd() throws RecognitionException {
6713                DdContext _localctx = new DdContext(_ctx, getState());
6714                enterRule(_localctx, 58, RULE_dd);
6715                try {
6716                        int _alt;
6717                        enterOuterAlt(_localctx, 1);
6718                        {
6719                        setState(813);
6720                        ddTagOpen();
6721                        setState(853);
6722                        _errHandler.sync(this);
6723                        _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6724                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6725                                if ( _alt==1 ) {
6726                                        {
6727                                        setState(851);
6728                                        _errHandler.sync(this);
6729                                        switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
6730                                        case 1:
6731                                                {
6732                                                setState(814);
6733                                                htmlTag();
6734                                                }
6735                                                break;
6736                                        case 2:
6737                                                {
6738                                                setState(815);
6739                                                singletonTag();
6740                                                }
6741                                                break;
6742                                        case 3:
6743                                                {
6744                                                setState(816);
6745                                                paragraph();
6746                                                }
6747                                                break;
6748                                        case 4:
6749                                                {
6750                                                setState(817);
6751                                                li();
6752                                                }
6753                                                break;
6754                                        case 5:
6755                                                {
6756                                                setState(818);
6757                                                tr();
6758                                                }
6759                                                break;
6760                                        case 6:
6761                                                {
6762                                                setState(819);
6763                                                td();
6764                                                }
6765                                                break;
6766                                        case 7:
6767                                                {
6768                                                setState(820);
6769                                                th();
6770                                                }
6771                                                break;
6772                                        case 8:
6773                                                {
6774                                                setState(821);
6775                                                body();
6776                                                }
6777                                                break;
6778                                        case 9:
6779                                                {
6780                                                setState(822);
6781                                                colgroup();
6782                                                }
6783                                                break;
6784                                        case 10:
6785                                                {
6786                                                setState(823);
6787                                                dt();
6788                                                }
6789                                                break;
6790                                        case 11:
6791                                                {
6792                                                setState(824);
6793                                                head();
6794                                                }
6795                                                break;
6796                                        case 12:
6797                                                {
6798                                                setState(825);
6799                                                html();
6800                                                }
6801                                                break;
6802                                        case 13:
6803                                                {
6804                                                setState(826);
6805                                                option();
6806                                                }
6807                                                break;
6808                                        case 14:
6809                                                {
6810                                                setState(827);
6811                                                tbody();
6812                                                }
6813                                                break;
6814                                        case 15:
6815                                                {
6816                                                setState(828);
6817                                                thead();
6818                                                }
6819                                                break;
6820                                        case 16:
6821                                                {
6822                                                setState(829);
6823                                                tfoot();
6824                                                }
6825                                                break;
6826                                        case 17:
6827                                                {
6828                                                setState(830);
6829                                                pTagOpen();
6830                                                }
6831                                                break;
6832                                        case 18:
6833                                                {
6834                                                setState(831);
6835                                                liTagOpen();
6836                                                }
6837                                                break;
6838                                        case 19:
6839                                                {
6840                                                setState(832);
6841                                                trTagOpen();
6842                                                }
6843                                                break;
6844                                        case 20:
6845                                                {
6846                                                setState(833);
6847                                                tdTagOpen();
6848                                                }
6849                                                break;
6850                                        case 21:
6851                                                {
6852                                                setState(834);
6853                                                thTagOpen();
6854                                                }
6855                                                break;
6856                                        case 22:
6857                                                {
6858                                                setState(835);
6859                                                bodyTagOpen();
6860                                                }
6861                                                break;
6862                                        case 23:
6863                                                {
6864                                                setState(836);
6865                                                colgroupTagOpen();
6866                                                }
6867                                                break;
6868                                        case 24:
6869                                                {
6870                                                setState(837);
6871                                                dtTagOpen();
6872                                                }
6873                                                break;
6874                                        case 25:
6875                                                {
6876                                                setState(838);
6877                                                headTagOpen();
6878                                                }
6879                                                break;
6880                                        case 26:
6881                                                {
6882                                                setState(839);
6883                                                htmlTagOpen();
6884                                                }
6885                                                break;
6886                                        case 27:
6887                                                {
6888                                                setState(840);
6889                                                optionTagOpen();
6890                                                }
6891                                                break;
6892                                        case 28:
6893                                                {
6894                                                setState(841);
6895                                                tbodyTagOpen();
6896                                                }
6897                                                break;
6898                                        case 29:
6899                                                {
6900                                                setState(842);
6901                                                theadTagOpen();
6902                                                }
6903                                                break;
6904                                        case 30:
6905                                                {
6906                                                setState(843);
6907                                                tfootTagOpen();
6908                                                }
6909                                                break;
6910                                        case 31:
6911                                                {
6912                                                {
6913                                                setState(844);
6914                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6915                                                setState(845);
6916                                                match(LEADING_ASTERISK);
6917                                                }
6918                                                }
6919                                                break;
6920                                        case 32:
6921                                                {
6922                                                setState(846);
6923                                                htmlComment();
6924                                                }
6925                                                break;
6926                                        case 33:
6927                                                {
6928                                                setState(847);
6929                                                match(CDATA);
6930                                                }
6931                                                break;
6932                                        case 34:
6933                                                {
6934                                                setState(848);
6935                                                match(NEWLINE);
6936                                                }
6937                                                break;
6938                                        case 35:
6939                                                {
6940                                                setState(849);
6941                                                text();
6942                                                }
6943                                                break;
6944                                        case 36:
6945                                                {
6946                                                setState(850);
6947                                                javadocInlineTag();
6948                                                }
6949                                                break;
6950                                        }
6951                                        } 
6952                                }
6953                                setState(855);
6954                                _errHandler.sync(this);
6955                                _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6956                        }
6957                        setState(856);
6958                        ddTagClose();
6959                        }
6960                }
6961                catch (RecognitionException re) {
6962                        _localctx.exception = re;
6963                        _errHandler.reportError(this, re);
6964                        _errHandler.recover(this, re);
6965                }
6966                finally {
6967                        exitRule();
6968                }
6969                return _localctx;
6970        }
6971
6972        public static class DtTagOpenContext extends ParserRuleContext {
6973                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6974                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6975                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6976                public List<AttributeContext> attribute() {
6977                        return getRuleContexts(AttributeContext.class);
6978                }
6979                public AttributeContext attribute(int i) {
6980                        return getRuleContext(AttributeContext.class,i);
6981                }
6982                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6983                public TerminalNode NEWLINE(int i) {
6984                        return getToken(JavadocParser.NEWLINE, i);
6985                }
6986                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6987                public TerminalNode LEADING_ASTERISK(int i) {
6988                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6989                }
6990                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6991                public TerminalNode WS(int i) {
6992                        return getToken(JavadocParser.WS, i);
6993                }
6994                public DtTagOpenContext(ParserRuleContext parent, int invokingState) {
6995                        super(parent, invokingState);
6996                }
6997                @Override public int getRuleIndex() { return RULE_dtTagOpen; }
6998                @Override
6999                public void enterRule(ParseTreeListener listener) {
7000                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this);
7001                }
7002                @Override
7003                public void exitRule(ParseTreeListener listener) {
7004                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this);
7005                }
7006                @Override
7007                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7008                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this);
7009                        else return visitor.visitChildren(this);
7010                }
7011        }
7012
7013        public final DtTagOpenContext dtTagOpen() throws RecognitionException {
7014                DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState());
7015                enterRule(_localctx, 60, RULE_dtTagOpen);
7016                int _la;
7017                try {
7018                        enterOuterAlt(_localctx, 1);
7019                        {
7020                        setState(858);
7021                        match(OPEN);
7022                        setState(859);
7023                        match(DT_HTML_TAG_NAME);
7024                        setState(866);
7025                        _errHandler.sync(this);
7026                        _la = _input.LA(1);
7027                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7028                                {
7029                                setState(864);
7030                                _errHandler.sync(this);
7031                                switch (_input.LA(1)) {
7032                                case HTML_TAG_NAME:
7033                                        {
7034                                        setState(860);
7035                                        attribute();
7036                                        }
7037                                        break;
7038                                case NEWLINE:
7039                                        {
7040                                        setState(861);
7041                                        match(NEWLINE);
7042                                        }
7043                                        break;
7044                                case LEADING_ASTERISK:
7045                                        {
7046                                        setState(862);
7047                                        match(LEADING_ASTERISK);
7048                                        }
7049                                        break;
7050                                case WS:
7051                                        {
7052                                        setState(863);
7053                                        match(WS);
7054                                        }
7055                                        break;
7056                                default:
7057                                        throw new NoViableAltException(this);
7058                                }
7059                                }
7060                                setState(868);
7061                                _errHandler.sync(this);
7062                                _la = _input.LA(1);
7063                        }
7064                        setState(869);
7065                        match(CLOSE);
7066                        }
7067                }
7068                catch (RecognitionException re) {
7069                        _localctx.exception = re;
7070                        _errHandler.reportError(this, re);
7071                        _errHandler.recover(this, re);
7072                }
7073                finally {
7074                        exitRule();
7075                }
7076                return _localctx;
7077        }
7078
7079        public static class DtTagCloseContext extends ParserRuleContext {
7080                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7081                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7082                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
7083                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7084                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7085                public TerminalNode NEWLINE(int i) {
7086                        return getToken(JavadocParser.NEWLINE, i);
7087                }
7088                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7089                public TerminalNode LEADING_ASTERISK(int i) {
7090                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7091                }
7092                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7093                public TerminalNode WS(int i) {
7094                        return getToken(JavadocParser.WS, i);
7095                }
7096                public DtTagCloseContext(ParserRuleContext parent, int invokingState) {
7097                        super(parent, invokingState);
7098                }
7099                @Override public int getRuleIndex() { return RULE_dtTagClose; }
7100                @Override
7101                public void enterRule(ParseTreeListener listener) {
7102                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this);
7103                }
7104                @Override
7105                public void exitRule(ParseTreeListener listener) {
7106                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this);
7107                }
7108                @Override
7109                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7110                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this);
7111                        else return visitor.visitChildren(this);
7112                }
7113        }
7114
7115        public final DtTagCloseContext dtTagClose() throws RecognitionException {
7116                DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState());
7117                enterRule(_localctx, 62, RULE_dtTagClose);
7118                int _la;
7119                try {
7120                        enterOuterAlt(_localctx, 1);
7121                        {
7122                        setState(871);
7123                        match(OPEN);
7124                        setState(872);
7125                        match(SLASH);
7126                        setState(873);
7127                        match(DT_HTML_TAG_NAME);
7128                        setState(877);
7129                        _errHandler.sync(this);
7130                        _la = _input.LA(1);
7131                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7132                                {
7133                                {
7134                                setState(874);
7135                                _la = _input.LA(1);
7136                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7137                                _errHandler.recoverInline(this);
7138                                }
7139                                else {
7140                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
7141                                        _errHandler.reportMatch(this);
7142                                        consume();
7143                                }
7144                                }
7145                                }
7146                                setState(879);
7147                                _errHandler.sync(this);
7148                                _la = _input.LA(1);
7149                        }
7150                        setState(880);
7151                        match(CLOSE);
7152                        }
7153                }
7154                catch (RecognitionException re) {
7155                        _localctx.exception = re;
7156                        _errHandler.reportError(this, re);
7157                        _errHandler.recover(this, re);
7158                }
7159                finally {
7160                        exitRule();
7161                }
7162                return _localctx;
7163        }
7164
7165        public static class DtContext extends ParserRuleContext {
7166                public DtTagOpenContext dtTagOpen() {
7167                        return getRuleContext(DtTagOpenContext.class,0);
7168                }
7169                public DtTagCloseContext dtTagClose() {
7170                        return getRuleContext(DtTagCloseContext.class,0);
7171                }
7172                public List<HtmlTagContext> htmlTag() {
7173                        return getRuleContexts(HtmlTagContext.class);
7174                }
7175                public HtmlTagContext htmlTag(int i) {
7176                        return getRuleContext(HtmlTagContext.class,i);
7177                }
7178                public List<SingletonTagContext> singletonTag() {
7179                        return getRuleContexts(SingletonTagContext.class);
7180                }
7181                public SingletonTagContext singletonTag(int i) {
7182                        return getRuleContext(SingletonTagContext.class,i);
7183                }
7184                public List<ParagraphContext> paragraph() {
7185                        return getRuleContexts(ParagraphContext.class);
7186                }
7187                public ParagraphContext paragraph(int i) {
7188                        return getRuleContext(ParagraphContext.class,i);
7189                }
7190                public List<LiContext> li() {
7191                        return getRuleContexts(LiContext.class);
7192                }
7193                public LiContext li(int i) {
7194                        return getRuleContext(LiContext.class,i);
7195                }
7196                public List<TrContext> tr() {
7197                        return getRuleContexts(TrContext.class);
7198                }
7199                public TrContext tr(int i) {
7200                        return getRuleContext(TrContext.class,i);
7201                }
7202                public List<TdContext> td() {
7203                        return getRuleContexts(TdContext.class);
7204                }
7205                public TdContext td(int i) {
7206                        return getRuleContext(TdContext.class,i);
7207                }
7208                public List<ThContext> th() {
7209                        return getRuleContexts(ThContext.class);
7210                }
7211                public ThContext th(int i) {
7212                        return getRuleContext(ThContext.class,i);
7213                }
7214                public List<BodyContext> body() {
7215                        return getRuleContexts(BodyContext.class);
7216                }
7217                public BodyContext body(int i) {
7218                        return getRuleContext(BodyContext.class,i);
7219                }
7220                public List<ColgroupContext> colgroup() {
7221                        return getRuleContexts(ColgroupContext.class);
7222                }
7223                public ColgroupContext colgroup(int i) {
7224                        return getRuleContext(ColgroupContext.class,i);
7225                }
7226                public List<DdContext> dd() {
7227                        return getRuleContexts(DdContext.class);
7228                }
7229                public DdContext dd(int i) {
7230                        return getRuleContext(DdContext.class,i);
7231                }
7232                public List<HeadContext> head() {
7233                        return getRuleContexts(HeadContext.class);
7234                }
7235                public HeadContext head(int i) {
7236                        return getRuleContext(HeadContext.class,i);
7237                }
7238                public List<HtmlContext> html() {
7239                        return getRuleContexts(HtmlContext.class);
7240                }
7241                public HtmlContext html(int i) {
7242                        return getRuleContext(HtmlContext.class,i);
7243                }
7244                public List<OptionContext> option() {
7245                        return getRuleContexts(OptionContext.class);
7246                }
7247                public OptionContext option(int i) {
7248                        return getRuleContext(OptionContext.class,i);
7249                }
7250                public List<TbodyContext> tbody() {
7251                        return getRuleContexts(TbodyContext.class);
7252                }
7253                public TbodyContext tbody(int i) {
7254                        return getRuleContext(TbodyContext.class,i);
7255                }
7256                public List<TheadContext> thead() {
7257                        return getRuleContexts(TheadContext.class);
7258                }
7259                public TheadContext thead(int i) {
7260                        return getRuleContext(TheadContext.class,i);
7261                }
7262                public List<TfootContext> tfoot() {
7263                        return getRuleContexts(TfootContext.class);
7264                }
7265                public TfootContext tfoot(int i) {
7266                        return getRuleContext(TfootContext.class,i);
7267                }
7268                public List<PTagOpenContext> pTagOpen() {
7269                        return getRuleContexts(PTagOpenContext.class);
7270                }
7271                public PTagOpenContext pTagOpen(int i) {
7272                        return getRuleContext(PTagOpenContext.class,i);
7273                }
7274                public List<LiTagOpenContext> liTagOpen() {
7275                        return getRuleContexts(LiTagOpenContext.class);
7276                }
7277                public LiTagOpenContext liTagOpen(int i) {
7278                        return getRuleContext(LiTagOpenContext.class,i);
7279                }
7280                public List<TrTagOpenContext> trTagOpen() {
7281                        return getRuleContexts(TrTagOpenContext.class);
7282                }
7283                public TrTagOpenContext trTagOpen(int i) {
7284                        return getRuleContext(TrTagOpenContext.class,i);
7285                }
7286                public List<TdTagOpenContext> tdTagOpen() {
7287                        return getRuleContexts(TdTagOpenContext.class);
7288                }
7289                public TdTagOpenContext tdTagOpen(int i) {
7290                        return getRuleContext(TdTagOpenContext.class,i);
7291                }
7292                public List<ThTagOpenContext> thTagOpen() {
7293                        return getRuleContexts(ThTagOpenContext.class);
7294                }
7295                public ThTagOpenContext thTagOpen(int i) {
7296                        return getRuleContext(ThTagOpenContext.class,i);
7297                }
7298                public List<BodyTagOpenContext> bodyTagOpen() {
7299                        return getRuleContexts(BodyTagOpenContext.class);
7300                }
7301                public BodyTagOpenContext bodyTagOpen(int i) {
7302                        return getRuleContext(BodyTagOpenContext.class,i);
7303                }
7304                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7305                        return getRuleContexts(ColgroupTagOpenContext.class);
7306                }
7307                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7308                        return getRuleContext(ColgroupTagOpenContext.class,i);
7309                }
7310                public List<DdTagOpenContext> ddTagOpen() {
7311                        return getRuleContexts(DdTagOpenContext.class);
7312                }
7313                public DdTagOpenContext ddTagOpen(int i) {
7314                        return getRuleContext(DdTagOpenContext.class,i);
7315                }
7316                public List<HeadTagOpenContext> headTagOpen() {
7317                        return getRuleContexts(HeadTagOpenContext.class);
7318                }
7319                public HeadTagOpenContext headTagOpen(int i) {
7320                        return getRuleContext(HeadTagOpenContext.class,i);
7321                }
7322                public List<HtmlTagOpenContext> htmlTagOpen() {
7323                        return getRuleContexts(HtmlTagOpenContext.class);
7324                }
7325                public HtmlTagOpenContext htmlTagOpen(int i) {
7326                        return getRuleContext(HtmlTagOpenContext.class,i);
7327                }
7328                public List<OptionTagOpenContext> optionTagOpen() {
7329                        return getRuleContexts(OptionTagOpenContext.class);
7330                }
7331                public OptionTagOpenContext optionTagOpen(int i) {
7332                        return getRuleContext(OptionTagOpenContext.class,i);
7333                }
7334                public List<TbodyTagOpenContext> tbodyTagOpen() {
7335                        return getRuleContexts(TbodyTagOpenContext.class);
7336                }
7337                public TbodyTagOpenContext tbodyTagOpen(int i) {
7338                        return getRuleContext(TbodyTagOpenContext.class,i);
7339                }
7340                public List<TheadTagOpenContext> theadTagOpen() {
7341                        return getRuleContexts(TheadTagOpenContext.class);
7342                }
7343                public TheadTagOpenContext theadTagOpen(int i) {
7344                        return getRuleContext(TheadTagOpenContext.class,i);
7345                }
7346                public List<TfootTagOpenContext> tfootTagOpen() {
7347                        return getRuleContexts(TfootTagOpenContext.class);
7348                }
7349                public TfootTagOpenContext tfootTagOpen(int i) {
7350                        return getRuleContext(TfootTagOpenContext.class,i);
7351                }
7352                public List<HtmlCommentContext> htmlComment() {
7353                        return getRuleContexts(HtmlCommentContext.class);
7354                }
7355                public HtmlCommentContext htmlComment(int i) {
7356                        return getRuleContext(HtmlCommentContext.class,i);
7357                }
7358                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7359                public TerminalNode CDATA(int i) {
7360                        return getToken(JavadocParser.CDATA, i);
7361                }
7362                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7363                public TerminalNode NEWLINE(int i) {
7364                        return getToken(JavadocParser.NEWLINE, i);
7365                }
7366                public List<TextContext> text() {
7367                        return getRuleContexts(TextContext.class);
7368                }
7369                public TextContext text(int i) {
7370                        return getRuleContext(TextContext.class,i);
7371                }
7372                public List<JavadocInlineTagContext> javadocInlineTag() {
7373                        return getRuleContexts(JavadocInlineTagContext.class);
7374                }
7375                public JavadocInlineTagContext javadocInlineTag(int i) {
7376                        return getRuleContext(JavadocInlineTagContext.class,i);
7377                }
7378                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7379                public TerminalNode LEADING_ASTERISK(int i) {
7380                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7381                }
7382                public DtContext(ParserRuleContext parent, int invokingState) {
7383                        super(parent, invokingState);
7384                }
7385                @Override public int getRuleIndex() { return RULE_dt; }
7386                @Override
7387                public void enterRule(ParseTreeListener listener) {
7388                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this);
7389                }
7390                @Override
7391                public void exitRule(ParseTreeListener listener) {
7392                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this);
7393                }
7394                @Override
7395                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7396                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this);
7397                        else return visitor.visitChildren(this);
7398                }
7399        }
7400
7401        public final DtContext dt() throws RecognitionException {
7402                DtContext _localctx = new DtContext(_ctx, getState());
7403                enterRule(_localctx, 64, RULE_dt);
7404                try {
7405                        int _alt;
7406                        enterOuterAlt(_localctx, 1);
7407                        {
7408                        setState(882);
7409                        dtTagOpen();
7410                        setState(922);
7411                        _errHandler.sync(this);
7412                        _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7413                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7414                                if ( _alt==1 ) {
7415                                        {
7416                                        setState(920);
7417                                        _errHandler.sync(this);
7418                                        switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
7419                                        case 1:
7420                                                {
7421                                                setState(883);
7422                                                htmlTag();
7423                                                }
7424                                                break;
7425                                        case 2:
7426                                                {
7427                                                setState(884);
7428                                                singletonTag();
7429                                                }
7430                                                break;
7431                                        case 3:
7432                                                {
7433                                                setState(885);
7434                                                paragraph();
7435                                                }
7436                                                break;
7437                                        case 4:
7438                                                {
7439                                                setState(886);
7440                                                li();
7441                                                }
7442                                                break;
7443                                        case 5:
7444                                                {
7445                                                setState(887);
7446                                                tr();
7447                                                }
7448                                                break;
7449                                        case 6:
7450                                                {
7451                                                setState(888);
7452                                                td();
7453                                                }
7454                                                break;
7455                                        case 7:
7456                                                {
7457                                                setState(889);
7458                                                th();
7459                                                }
7460                                                break;
7461                                        case 8:
7462                                                {
7463                                                setState(890);
7464                                                body();
7465                                                }
7466                                                break;
7467                                        case 9:
7468                                                {
7469                                                setState(891);
7470                                                colgroup();
7471                                                }
7472                                                break;
7473                                        case 10:
7474                                                {
7475                                                setState(892);
7476                                                dd();
7477                                                }
7478                                                break;
7479                                        case 11:
7480                                                {
7481                                                setState(893);
7482                                                head();
7483                                                }
7484                                                break;
7485                                        case 12:
7486                                                {
7487                                                setState(894);
7488                                                html();
7489                                                }
7490                                                break;
7491                                        case 13:
7492                                                {
7493                                                setState(895);
7494                                                option();
7495                                                }
7496                                                break;
7497                                        case 14:
7498                                                {
7499                                                setState(896);
7500                                                tbody();
7501                                                }
7502                                                break;
7503                                        case 15:
7504                                                {
7505                                                setState(897);
7506                                                thead();
7507                                                }
7508                                                break;
7509                                        case 16:
7510                                                {
7511                                                setState(898);
7512                                                tfoot();
7513                                                }
7514                                                break;
7515                                        case 17:
7516                                                {
7517                                                setState(899);
7518                                                pTagOpen();
7519                                                }
7520                                                break;
7521                                        case 18:
7522                                                {
7523                                                setState(900);
7524                                                liTagOpen();
7525                                                }
7526                                                break;
7527                                        case 19:
7528                                                {
7529                                                setState(901);
7530                                                trTagOpen();
7531                                                }
7532                                                break;
7533                                        case 20:
7534                                                {
7535                                                setState(902);
7536                                                tdTagOpen();
7537                                                }
7538                                                break;
7539                                        case 21:
7540                                                {
7541                                                setState(903);
7542                                                thTagOpen();
7543                                                }
7544                                                break;
7545                                        case 22:
7546                                                {
7547                                                setState(904);
7548                                                bodyTagOpen();
7549                                                }
7550                                                break;
7551                                        case 23:
7552                                                {
7553                                                setState(905);
7554                                                colgroupTagOpen();
7555                                                }
7556                                                break;
7557                                        case 24:
7558                                                {
7559                                                setState(906);
7560                                                ddTagOpen();
7561                                                }
7562                                                break;
7563                                        case 25:
7564                                                {
7565                                                setState(907);
7566                                                headTagOpen();
7567                                                }
7568                                                break;
7569                                        case 26:
7570                                                {
7571                                                setState(908);
7572                                                htmlTagOpen();
7573                                                }
7574                                                break;
7575                                        case 27:
7576                                                {
7577                                                setState(909);
7578                                                optionTagOpen();
7579                                                }
7580                                                break;
7581                                        case 28:
7582                                                {
7583                                                setState(910);
7584                                                tbodyTagOpen();
7585                                                }
7586                                                break;
7587                                        case 29:
7588                                                {
7589                                                setState(911);
7590                                                theadTagOpen();
7591                                                }
7592                                                break;
7593                                        case 30:
7594                                                {
7595                                                setState(912);
7596                                                tfootTagOpen();
7597                                                }
7598                                                break;
7599                                        case 31:
7600                                                {
7601                                                {
7602                                                setState(913);
7603                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7604                                                setState(914);
7605                                                match(LEADING_ASTERISK);
7606                                                }
7607                                                }
7608                                                break;
7609                                        case 32:
7610                                                {
7611                                                setState(915);
7612                                                htmlComment();
7613                                                }
7614                                                break;
7615                                        case 33:
7616                                                {
7617                                                setState(916);
7618                                                match(CDATA);
7619                                                }
7620                                                break;
7621                                        case 34:
7622                                                {
7623                                                setState(917);
7624                                                match(NEWLINE);
7625                                                }
7626                                                break;
7627                                        case 35:
7628                                                {
7629                                                setState(918);
7630                                                text();
7631                                                }
7632                                                break;
7633                                        case 36:
7634                                                {
7635                                                setState(919);
7636                                                javadocInlineTag();
7637                                                }
7638                                                break;
7639                                        }
7640                                        } 
7641                                }
7642                                setState(924);
7643                                _errHandler.sync(this);
7644                                _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7645                        }
7646                        setState(925);
7647                        dtTagClose();
7648                        }
7649                }
7650                catch (RecognitionException re) {
7651                        _localctx.exception = re;
7652                        _errHandler.reportError(this, re);
7653                        _errHandler.recover(this, re);
7654                }
7655                finally {
7656                        exitRule();
7657                }
7658                return _localctx;
7659        }
7660
7661        public static class HeadTagOpenContext extends ParserRuleContext {
7662                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7663                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7664                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7665                public List<AttributeContext> attribute() {
7666                        return getRuleContexts(AttributeContext.class);
7667                }
7668                public AttributeContext attribute(int i) {
7669                        return getRuleContext(AttributeContext.class,i);
7670                }
7671                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7672                public TerminalNode NEWLINE(int i) {
7673                        return getToken(JavadocParser.NEWLINE, i);
7674                }
7675                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7676                public TerminalNode LEADING_ASTERISK(int i) {
7677                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7678                }
7679                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7680                public TerminalNode WS(int i) {
7681                        return getToken(JavadocParser.WS, i);
7682                }
7683                public HeadTagOpenContext(ParserRuleContext parent, int invokingState) {
7684                        super(parent, invokingState);
7685                }
7686                @Override public int getRuleIndex() { return RULE_headTagOpen; }
7687                @Override
7688                public void enterRule(ParseTreeListener listener) {
7689                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this);
7690                }
7691                @Override
7692                public void exitRule(ParseTreeListener listener) {
7693                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this);
7694                }
7695                @Override
7696                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7697                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this);
7698                        else return visitor.visitChildren(this);
7699                }
7700        }
7701
7702        public final HeadTagOpenContext headTagOpen() throws RecognitionException {
7703                HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState());
7704                enterRule(_localctx, 66, RULE_headTagOpen);
7705                int _la;
7706                try {
7707                        enterOuterAlt(_localctx, 1);
7708                        {
7709                        setState(927);
7710                        match(OPEN);
7711                        setState(928);
7712                        match(HEAD_HTML_TAG_NAME);
7713                        setState(935);
7714                        _errHandler.sync(this);
7715                        _la = _input.LA(1);
7716                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7717                                {
7718                                setState(933);
7719                                _errHandler.sync(this);
7720                                switch (_input.LA(1)) {
7721                                case HTML_TAG_NAME:
7722                                        {
7723                                        setState(929);
7724                                        attribute();
7725                                        }
7726                                        break;
7727                                case NEWLINE:
7728                                        {
7729                                        setState(930);
7730                                        match(NEWLINE);
7731                                        }
7732                                        break;
7733                                case LEADING_ASTERISK:
7734                                        {
7735                                        setState(931);
7736                                        match(LEADING_ASTERISK);
7737                                        }
7738                                        break;
7739                                case WS:
7740                                        {
7741                                        setState(932);
7742                                        match(WS);
7743                                        }
7744                                        break;
7745                                default:
7746                                        throw new NoViableAltException(this);
7747                                }
7748                                }
7749                                setState(937);
7750                                _errHandler.sync(this);
7751                                _la = _input.LA(1);
7752                        }
7753                        setState(938);
7754                        match(CLOSE);
7755                        }
7756                }
7757                catch (RecognitionException re) {
7758                        _localctx.exception = re;
7759                        _errHandler.reportError(this, re);
7760                        _errHandler.recover(this, re);
7761                }
7762                finally {
7763                        exitRule();
7764                }
7765                return _localctx;
7766        }
7767
7768        public static class HeadTagCloseContext extends ParserRuleContext {
7769                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7770                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7771                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7772                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7773                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7774                public TerminalNode NEWLINE(int i) {
7775                        return getToken(JavadocParser.NEWLINE, i);
7776                }
7777                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7778                public TerminalNode LEADING_ASTERISK(int i) {
7779                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7780                }
7781                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7782                public TerminalNode WS(int i) {
7783                        return getToken(JavadocParser.WS, i);
7784                }
7785                public HeadTagCloseContext(ParserRuleContext parent, int invokingState) {
7786                        super(parent, invokingState);
7787                }
7788                @Override public int getRuleIndex() { return RULE_headTagClose; }
7789                @Override
7790                public void enterRule(ParseTreeListener listener) {
7791                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this);
7792                }
7793                @Override
7794                public void exitRule(ParseTreeListener listener) {
7795                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this);
7796                }
7797                @Override
7798                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7799                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this);
7800                        else return visitor.visitChildren(this);
7801                }
7802        }
7803
7804        public final HeadTagCloseContext headTagClose() throws RecognitionException {
7805                HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState());
7806                enterRule(_localctx, 68, RULE_headTagClose);
7807                int _la;
7808                try {
7809                        enterOuterAlt(_localctx, 1);
7810                        {
7811                        setState(940);
7812                        match(OPEN);
7813                        setState(941);
7814                        match(SLASH);
7815                        setState(942);
7816                        match(HEAD_HTML_TAG_NAME);
7817                        setState(946);
7818                        _errHandler.sync(this);
7819                        _la = _input.LA(1);
7820                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7821                                {
7822                                {
7823                                setState(943);
7824                                _la = _input.LA(1);
7825                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7826                                _errHandler.recoverInline(this);
7827                                }
7828                                else {
7829                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
7830                                        _errHandler.reportMatch(this);
7831                                        consume();
7832                                }
7833                                }
7834                                }
7835                                setState(948);
7836                                _errHandler.sync(this);
7837                                _la = _input.LA(1);
7838                        }
7839                        setState(949);
7840                        match(CLOSE);
7841                        }
7842                }
7843                catch (RecognitionException re) {
7844                        _localctx.exception = re;
7845                        _errHandler.reportError(this, re);
7846                        _errHandler.recover(this, re);
7847                }
7848                finally {
7849                        exitRule();
7850                }
7851                return _localctx;
7852        }
7853
7854        public static class HeadContext extends ParserRuleContext {
7855                public HeadTagOpenContext headTagOpen() {
7856                        return getRuleContext(HeadTagOpenContext.class,0);
7857                }
7858                public HeadTagCloseContext headTagClose() {
7859                        return getRuleContext(HeadTagCloseContext.class,0);
7860                }
7861                public List<HtmlTagContext> htmlTag() {
7862                        return getRuleContexts(HtmlTagContext.class);
7863                }
7864                public HtmlTagContext htmlTag(int i) {
7865                        return getRuleContext(HtmlTagContext.class,i);
7866                }
7867                public List<SingletonTagContext> singletonTag() {
7868                        return getRuleContexts(SingletonTagContext.class);
7869                }
7870                public SingletonTagContext singletonTag(int i) {
7871                        return getRuleContext(SingletonTagContext.class,i);
7872                }
7873                public List<ParagraphContext> paragraph() {
7874                        return getRuleContexts(ParagraphContext.class);
7875                }
7876                public ParagraphContext paragraph(int i) {
7877                        return getRuleContext(ParagraphContext.class,i);
7878                }
7879                public List<LiContext> li() {
7880                        return getRuleContexts(LiContext.class);
7881                }
7882                public LiContext li(int i) {
7883                        return getRuleContext(LiContext.class,i);
7884                }
7885                public List<TrContext> tr() {
7886                        return getRuleContexts(TrContext.class);
7887                }
7888                public TrContext tr(int i) {
7889                        return getRuleContext(TrContext.class,i);
7890                }
7891                public List<TdContext> td() {
7892                        return getRuleContexts(TdContext.class);
7893                }
7894                public TdContext td(int i) {
7895                        return getRuleContext(TdContext.class,i);
7896                }
7897                public List<ThContext> th() {
7898                        return getRuleContexts(ThContext.class);
7899                }
7900                public ThContext th(int i) {
7901                        return getRuleContext(ThContext.class,i);
7902                }
7903                public List<BodyContext> body() {
7904                        return getRuleContexts(BodyContext.class);
7905                }
7906                public BodyContext body(int i) {
7907                        return getRuleContext(BodyContext.class,i);
7908                }
7909                public List<ColgroupContext> colgroup() {
7910                        return getRuleContexts(ColgroupContext.class);
7911                }
7912                public ColgroupContext colgroup(int i) {
7913                        return getRuleContext(ColgroupContext.class,i);
7914                }
7915                public List<DdContext> dd() {
7916                        return getRuleContexts(DdContext.class);
7917                }
7918                public DdContext dd(int i) {
7919                        return getRuleContext(DdContext.class,i);
7920                }
7921                public List<DtContext> dt() {
7922                        return getRuleContexts(DtContext.class);
7923                }
7924                public DtContext dt(int i) {
7925                        return getRuleContext(DtContext.class,i);
7926                }
7927                public List<HtmlContext> html() {
7928                        return getRuleContexts(HtmlContext.class);
7929                }
7930                public HtmlContext html(int i) {
7931                        return getRuleContext(HtmlContext.class,i);
7932                }
7933                public List<OptionContext> option() {
7934                        return getRuleContexts(OptionContext.class);
7935                }
7936                public OptionContext option(int i) {
7937                        return getRuleContext(OptionContext.class,i);
7938                }
7939                public List<TbodyContext> tbody() {
7940                        return getRuleContexts(TbodyContext.class);
7941                }
7942                public TbodyContext tbody(int i) {
7943                        return getRuleContext(TbodyContext.class,i);
7944                }
7945                public List<TheadContext> thead() {
7946                        return getRuleContexts(TheadContext.class);
7947                }
7948                public TheadContext thead(int i) {
7949                        return getRuleContext(TheadContext.class,i);
7950                }
7951                public List<TfootContext> tfoot() {
7952                        return getRuleContexts(TfootContext.class);
7953                }
7954                public TfootContext tfoot(int i) {
7955                        return getRuleContext(TfootContext.class,i);
7956                }
7957                public List<PTagOpenContext> pTagOpen() {
7958                        return getRuleContexts(PTagOpenContext.class);
7959                }
7960                public PTagOpenContext pTagOpen(int i) {
7961                        return getRuleContext(PTagOpenContext.class,i);
7962                }
7963                public List<LiTagOpenContext> liTagOpen() {
7964                        return getRuleContexts(LiTagOpenContext.class);
7965                }
7966                public LiTagOpenContext liTagOpen(int i) {
7967                        return getRuleContext(LiTagOpenContext.class,i);
7968                }
7969                public List<TrTagOpenContext> trTagOpen() {
7970                        return getRuleContexts(TrTagOpenContext.class);
7971                }
7972                public TrTagOpenContext trTagOpen(int i) {
7973                        return getRuleContext(TrTagOpenContext.class,i);
7974                }
7975                public List<TdTagOpenContext> tdTagOpen() {
7976                        return getRuleContexts(TdTagOpenContext.class);
7977                }
7978                public TdTagOpenContext tdTagOpen(int i) {
7979                        return getRuleContext(TdTagOpenContext.class,i);
7980                }
7981                public List<ThTagOpenContext> thTagOpen() {
7982                        return getRuleContexts(ThTagOpenContext.class);
7983                }
7984                public ThTagOpenContext thTagOpen(int i) {
7985                        return getRuleContext(ThTagOpenContext.class,i);
7986                }
7987                public List<BodyTagOpenContext> bodyTagOpen() {
7988                        return getRuleContexts(BodyTagOpenContext.class);
7989                }
7990                public BodyTagOpenContext bodyTagOpen(int i) {
7991                        return getRuleContext(BodyTagOpenContext.class,i);
7992                }
7993                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7994                        return getRuleContexts(ColgroupTagOpenContext.class);
7995                }
7996                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7997                        return getRuleContext(ColgroupTagOpenContext.class,i);
7998                }
7999                public List<DdTagOpenContext> ddTagOpen() {
8000                        return getRuleContexts(DdTagOpenContext.class);
8001                }
8002                public DdTagOpenContext ddTagOpen(int i) {
8003                        return getRuleContext(DdTagOpenContext.class,i);
8004                }
8005                public List<DtTagOpenContext> dtTagOpen() {
8006                        return getRuleContexts(DtTagOpenContext.class);
8007                }
8008                public DtTagOpenContext dtTagOpen(int i) {
8009                        return getRuleContext(DtTagOpenContext.class,i);
8010                }
8011                public List<HtmlTagOpenContext> htmlTagOpen() {
8012                        return getRuleContexts(HtmlTagOpenContext.class);
8013                }
8014                public HtmlTagOpenContext htmlTagOpen(int i) {
8015                        return getRuleContext(HtmlTagOpenContext.class,i);
8016                }
8017                public List<OptionTagOpenContext> optionTagOpen() {
8018                        return getRuleContexts(OptionTagOpenContext.class);
8019                }
8020                public OptionTagOpenContext optionTagOpen(int i) {
8021                        return getRuleContext(OptionTagOpenContext.class,i);
8022                }
8023                public List<TbodyTagOpenContext> tbodyTagOpen() {
8024                        return getRuleContexts(TbodyTagOpenContext.class);
8025                }
8026                public TbodyTagOpenContext tbodyTagOpen(int i) {
8027                        return getRuleContext(TbodyTagOpenContext.class,i);
8028                }
8029                public List<TheadTagOpenContext> theadTagOpen() {
8030                        return getRuleContexts(TheadTagOpenContext.class);
8031                }
8032                public TheadTagOpenContext theadTagOpen(int i) {
8033                        return getRuleContext(TheadTagOpenContext.class,i);
8034                }
8035                public List<TfootTagOpenContext> tfootTagOpen() {
8036                        return getRuleContexts(TfootTagOpenContext.class);
8037                }
8038                public TfootTagOpenContext tfootTagOpen(int i) {
8039                        return getRuleContext(TfootTagOpenContext.class,i);
8040                }
8041                public List<HtmlCommentContext> htmlComment() {
8042                        return getRuleContexts(HtmlCommentContext.class);
8043                }
8044                public HtmlCommentContext htmlComment(int i) {
8045                        return getRuleContext(HtmlCommentContext.class,i);
8046                }
8047                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8048                public TerminalNode CDATA(int i) {
8049                        return getToken(JavadocParser.CDATA, i);
8050                }
8051                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8052                public TerminalNode NEWLINE(int i) {
8053                        return getToken(JavadocParser.NEWLINE, i);
8054                }
8055                public List<TextContext> text() {
8056                        return getRuleContexts(TextContext.class);
8057                }
8058                public TextContext text(int i) {
8059                        return getRuleContext(TextContext.class,i);
8060                }
8061                public List<JavadocInlineTagContext> javadocInlineTag() {
8062                        return getRuleContexts(JavadocInlineTagContext.class);
8063                }
8064                public JavadocInlineTagContext javadocInlineTag(int i) {
8065                        return getRuleContext(JavadocInlineTagContext.class,i);
8066                }
8067                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8068                public TerminalNode LEADING_ASTERISK(int i) {
8069                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8070                }
8071                public HeadContext(ParserRuleContext parent, int invokingState) {
8072                        super(parent, invokingState);
8073                }
8074                @Override public int getRuleIndex() { return RULE_head; }
8075                @Override
8076                public void enterRule(ParseTreeListener listener) {
8077                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this);
8078                }
8079                @Override
8080                public void exitRule(ParseTreeListener listener) {
8081                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this);
8082                }
8083                @Override
8084                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8085                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this);
8086                        else return visitor.visitChildren(this);
8087                }
8088        }
8089
8090        public final HeadContext head() throws RecognitionException {
8091                HeadContext _localctx = new HeadContext(_ctx, getState());
8092                enterRule(_localctx, 70, RULE_head);
8093                try {
8094                        int _alt;
8095                        enterOuterAlt(_localctx, 1);
8096                        {
8097                        setState(951);
8098                        headTagOpen();
8099                        setState(991);
8100                        _errHandler.sync(this);
8101                        _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8102                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8103                                if ( _alt==1 ) {
8104                                        {
8105                                        setState(989);
8106                                        _errHandler.sync(this);
8107                                        switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
8108                                        case 1:
8109                                                {
8110                                                setState(952);
8111                                                htmlTag();
8112                                                }
8113                                                break;
8114                                        case 2:
8115                                                {
8116                                                setState(953);
8117                                                singletonTag();
8118                                                }
8119                                                break;
8120                                        case 3:
8121                                                {
8122                                                setState(954);
8123                                                paragraph();
8124                                                }
8125                                                break;
8126                                        case 4:
8127                                                {
8128                                                setState(955);
8129                                                li();
8130                                                }
8131                                                break;
8132                                        case 5:
8133                                                {
8134                                                setState(956);
8135                                                tr();
8136                                                }
8137                                                break;
8138                                        case 6:
8139                                                {
8140                                                setState(957);
8141                                                td();
8142                                                }
8143                                                break;
8144                                        case 7:
8145                                                {
8146                                                setState(958);
8147                                                th();
8148                                                }
8149                                                break;
8150                                        case 8:
8151                                                {
8152                                                setState(959);
8153                                                body();
8154                                                }
8155                                                break;
8156                                        case 9:
8157                                                {
8158                                                setState(960);
8159                                                colgroup();
8160                                                }
8161                                                break;
8162                                        case 10:
8163                                                {
8164                                                setState(961);
8165                                                dd();
8166                                                }
8167                                                break;
8168                                        case 11:
8169                                                {
8170                                                setState(962);
8171                                                dt();
8172                                                }
8173                                                break;
8174                                        case 12:
8175                                                {
8176                                                setState(963);
8177                                                html();
8178                                                }
8179                                                break;
8180                                        case 13:
8181                                                {
8182                                                setState(964);
8183                                                option();
8184                                                }
8185                                                break;
8186                                        case 14:
8187                                                {
8188                                                setState(965);
8189                                                tbody();
8190                                                }
8191                                                break;
8192                                        case 15:
8193                                                {
8194                                                setState(966);
8195                                                thead();
8196                                                }
8197                                                break;
8198                                        case 16:
8199                                                {
8200                                                setState(967);
8201                                                tfoot();
8202                                                }
8203                                                break;
8204                                        case 17:
8205                                                {
8206                                                setState(968);
8207                                                pTagOpen();
8208                                                }
8209                                                break;
8210                                        case 18:
8211                                                {
8212                                                setState(969);
8213                                                liTagOpen();
8214                                                }
8215                                                break;
8216                                        case 19:
8217                                                {
8218                                                setState(970);
8219                                                trTagOpen();
8220                                                }
8221                                                break;
8222                                        case 20:
8223                                                {
8224                                                setState(971);
8225                                                tdTagOpen();
8226                                                }
8227                                                break;
8228                                        case 21:
8229                                                {
8230                                                setState(972);
8231                                                thTagOpen();
8232                                                }
8233                                                break;
8234                                        case 22:
8235                                                {
8236                                                setState(973);
8237                                                bodyTagOpen();
8238                                                }
8239                                                break;
8240                                        case 23:
8241                                                {
8242                                                setState(974);
8243                                                colgroupTagOpen();
8244                                                }
8245                                                break;
8246                                        case 24:
8247                                                {
8248                                                setState(975);
8249                                                ddTagOpen();
8250                                                }
8251                                                break;
8252                                        case 25:
8253                                                {
8254                                                setState(976);
8255                                                dtTagOpen();
8256                                                }
8257                                                break;
8258                                        case 26:
8259                                                {
8260                                                setState(977);
8261                                                htmlTagOpen();
8262                                                }
8263                                                break;
8264                                        case 27:
8265                                                {
8266                                                setState(978);
8267                                                optionTagOpen();
8268                                                }
8269                                                break;
8270                                        case 28:
8271                                                {
8272                                                setState(979);
8273                                                tbodyTagOpen();
8274                                                }
8275                                                break;
8276                                        case 29:
8277                                                {
8278                                                setState(980);
8279                                                theadTagOpen();
8280                                                }
8281                                                break;
8282                                        case 30:
8283                                                {
8284                                                setState(981);
8285                                                tfootTagOpen();
8286                                                }
8287                                                break;
8288                                        case 31:
8289                                                {
8290                                                {
8291                                                setState(982);
8292                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8293                                                setState(983);
8294                                                match(LEADING_ASTERISK);
8295                                                }
8296                                                }
8297                                                break;
8298                                        case 32:
8299                                                {
8300                                                setState(984);
8301                                                htmlComment();
8302                                                }
8303                                                break;
8304                                        case 33:
8305                                                {
8306                                                setState(985);
8307                                                match(CDATA);
8308                                                }
8309                                                break;
8310                                        case 34:
8311                                                {
8312                                                setState(986);
8313                                                match(NEWLINE);
8314                                                }
8315                                                break;
8316                                        case 35:
8317                                                {
8318                                                setState(987);
8319                                                text();
8320                                                }
8321                                                break;
8322                                        case 36:
8323                                                {
8324                                                setState(988);
8325                                                javadocInlineTag();
8326                                                }
8327                                                break;
8328                                        }
8329                                        } 
8330                                }
8331                                setState(993);
8332                                _errHandler.sync(this);
8333                                _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8334                        }
8335                        setState(994);
8336                        headTagClose();
8337                        }
8338                }
8339                catch (RecognitionException re) {
8340                        _localctx.exception = re;
8341                        _errHandler.reportError(this, re);
8342                        _errHandler.recover(this, re);
8343                }
8344                finally {
8345                        exitRule();
8346                }
8347                return _localctx;
8348        }
8349
8350        public static class HtmlTagOpenContext extends ParserRuleContext {
8351                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8352                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8353                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8354                public List<AttributeContext> attribute() {
8355                        return getRuleContexts(AttributeContext.class);
8356                }
8357                public AttributeContext attribute(int i) {
8358                        return getRuleContext(AttributeContext.class,i);
8359                }
8360                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8361                public TerminalNode NEWLINE(int i) {
8362                        return getToken(JavadocParser.NEWLINE, i);
8363                }
8364                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8365                public TerminalNode LEADING_ASTERISK(int i) {
8366                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8367                }
8368                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8369                public TerminalNode WS(int i) {
8370                        return getToken(JavadocParser.WS, i);
8371                }
8372                public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) {
8373                        super(parent, invokingState);
8374                }
8375                @Override public int getRuleIndex() { return RULE_htmlTagOpen; }
8376                @Override
8377                public void enterRule(ParseTreeListener listener) {
8378                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this);
8379                }
8380                @Override
8381                public void exitRule(ParseTreeListener listener) {
8382                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this);
8383                }
8384                @Override
8385                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8386                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this);
8387                        else return visitor.visitChildren(this);
8388                }
8389        }
8390
8391        public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException {
8392                HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState());
8393                enterRule(_localctx, 72, RULE_htmlTagOpen);
8394                int _la;
8395                try {
8396                        enterOuterAlt(_localctx, 1);
8397                        {
8398                        setState(996);
8399                        match(OPEN);
8400                        setState(997);
8401                        match(HTML_HTML_TAG_NAME);
8402                        setState(1004);
8403                        _errHandler.sync(this);
8404                        _la = _input.LA(1);
8405                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8406                                {
8407                                setState(1002);
8408                                _errHandler.sync(this);
8409                                switch (_input.LA(1)) {
8410                                case HTML_TAG_NAME:
8411                                        {
8412                                        setState(998);
8413                                        attribute();
8414                                        }
8415                                        break;
8416                                case NEWLINE:
8417                                        {
8418                                        setState(999);
8419                                        match(NEWLINE);
8420                                        }
8421                                        break;
8422                                case LEADING_ASTERISK:
8423                                        {
8424                                        setState(1000);
8425                                        match(LEADING_ASTERISK);
8426                                        }
8427                                        break;
8428                                case WS:
8429                                        {
8430                                        setState(1001);
8431                                        match(WS);
8432                                        }
8433                                        break;
8434                                default:
8435                                        throw new NoViableAltException(this);
8436                                }
8437                                }
8438                                setState(1006);
8439                                _errHandler.sync(this);
8440                                _la = _input.LA(1);
8441                        }
8442                        setState(1007);
8443                        match(CLOSE);
8444                        }
8445                }
8446                catch (RecognitionException re) {
8447                        _localctx.exception = re;
8448                        _errHandler.reportError(this, re);
8449                        _errHandler.recover(this, re);
8450                }
8451                finally {
8452                        exitRule();
8453                }
8454                return _localctx;
8455        }
8456
8457        public static class HtmlTagCloseContext extends ParserRuleContext {
8458                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8459                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8460                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8461                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8462                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8463                public TerminalNode NEWLINE(int i) {
8464                        return getToken(JavadocParser.NEWLINE, i);
8465                }
8466                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8467                public TerminalNode LEADING_ASTERISK(int i) {
8468                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8469                }
8470                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8471                public TerminalNode WS(int i) {
8472                        return getToken(JavadocParser.WS, i);
8473                }
8474                public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) {
8475                        super(parent, invokingState);
8476                }
8477                @Override public int getRuleIndex() { return RULE_htmlTagClose; }
8478                @Override
8479                public void enterRule(ParseTreeListener listener) {
8480                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this);
8481                }
8482                @Override
8483                public void exitRule(ParseTreeListener listener) {
8484                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this);
8485                }
8486                @Override
8487                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8488                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this);
8489                        else return visitor.visitChildren(this);
8490                }
8491        }
8492
8493        public final HtmlTagCloseContext htmlTagClose() throws RecognitionException {
8494                HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState());
8495                enterRule(_localctx, 74, RULE_htmlTagClose);
8496                int _la;
8497                try {
8498                        enterOuterAlt(_localctx, 1);
8499                        {
8500                        setState(1009);
8501                        match(OPEN);
8502                        setState(1010);
8503                        match(SLASH);
8504                        setState(1011);
8505                        match(HTML_HTML_TAG_NAME);
8506                        setState(1015);
8507                        _errHandler.sync(this);
8508                        _la = _input.LA(1);
8509                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8510                                {
8511                                {
8512                                setState(1012);
8513                                _la = _input.LA(1);
8514                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8515                                _errHandler.recoverInline(this);
8516                                }
8517                                else {
8518                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
8519                                        _errHandler.reportMatch(this);
8520                                        consume();
8521                                }
8522                                }
8523                                }
8524                                setState(1017);
8525                                _errHandler.sync(this);
8526                                _la = _input.LA(1);
8527                        }
8528                        setState(1018);
8529                        match(CLOSE);
8530                        }
8531                }
8532                catch (RecognitionException re) {
8533                        _localctx.exception = re;
8534                        _errHandler.reportError(this, re);
8535                        _errHandler.recover(this, re);
8536                }
8537                finally {
8538                        exitRule();
8539                }
8540                return _localctx;
8541        }
8542
8543        public static class HtmlContext extends ParserRuleContext {
8544                public HtmlTagOpenContext htmlTagOpen() {
8545                        return getRuleContext(HtmlTagOpenContext.class,0);
8546                }
8547                public HtmlTagCloseContext htmlTagClose() {
8548                        return getRuleContext(HtmlTagCloseContext.class,0);
8549                }
8550                public List<HtmlTagContext> htmlTag() {
8551                        return getRuleContexts(HtmlTagContext.class);
8552                }
8553                public HtmlTagContext htmlTag(int i) {
8554                        return getRuleContext(HtmlTagContext.class,i);
8555                }
8556                public List<SingletonTagContext> singletonTag() {
8557                        return getRuleContexts(SingletonTagContext.class);
8558                }
8559                public SingletonTagContext singletonTag(int i) {
8560                        return getRuleContext(SingletonTagContext.class,i);
8561                }
8562                public List<ParagraphContext> paragraph() {
8563                        return getRuleContexts(ParagraphContext.class);
8564                }
8565                public ParagraphContext paragraph(int i) {
8566                        return getRuleContext(ParagraphContext.class,i);
8567                }
8568                public List<LiContext> li() {
8569                        return getRuleContexts(LiContext.class);
8570                }
8571                public LiContext li(int i) {
8572                        return getRuleContext(LiContext.class,i);
8573                }
8574                public List<TrContext> tr() {
8575                        return getRuleContexts(TrContext.class);
8576                }
8577                public TrContext tr(int i) {
8578                        return getRuleContext(TrContext.class,i);
8579                }
8580                public List<TdContext> td() {
8581                        return getRuleContexts(TdContext.class);
8582                }
8583                public TdContext td(int i) {
8584                        return getRuleContext(TdContext.class,i);
8585                }
8586                public List<ThContext> th() {
8587                        return getRuleContexts(ThContext.class);
8588                }
8589                public ThContext th(int i) {
8590                        return getRuleContext(ThContext.class,i);
8591                }
8592                public List<BodyContext> body() {
8593                        return getRuleContexts(BodyContext.class);
8594                }
8595                public BodyContext body(int i) {
8596                        return getRuleContext(BodyContext.class,i);
8597                }
8598                public List<ColgroupContext> colgroup() {
8599                        return getRuleContexts(ColgroupContext.class);
8600                }
8601                public ColgroupContext colgroup(int i) {
8602                        return getRuleContext(ColgroupContext.class,i);
8603                }
8604                public List<DdContext> dd() {
8605                        return getRuleContexts(DdContext.class);
8606                }
8607                public DdContext dd(int i) {
8608                        return getRuleContext(DdContext.class,i);
8609                }
8610                public List<DtContext> dt() {
8611                        return getRuleContexts(DtContext.class);
8612                }
8613                public DtContext dt(int i) {
8614                        return getRuleContext(DtContext.class,i);
8615                }
8616                public List<HeadContext> head() {
8617                        return getRuleContexts(HeadContext.class);
8618                }
8619                public HeadContext head(int i) {
8620                        return getRuleContext(HeadContext.class,i);
8621                }
8622                public List<OptionContext> option() {
8623                        return getRuleContexts(OptionContext.class);
8624                }
8625                public OptionContext option(int i) {
8626                        return getRuleContext(OptionContext.class,i);
8627                }
8628                public List<TbodyContext> tbody() {
8629                        return getRuleContexts(TbodyContext.class);
8630                }
8631                public TbodyContext tbody(int i) {
8632                        return getRuleContext(TbodyContext.class,i);
8633                }
8634                public List<TheadContext> thead() {
8635                        return getRuleContexts(TheadContext.class);
8636                }
8637                public TheadContext thead(int i) {
8638                        return getRuleContext(TheadContext.class,i);
8639                }
8640                public List<TfootContext> tfoot() {
8641                        return getRuleContexts(TfootContext.class);
8642                }
8643                public TfootContext tfoot(int i) {
8644                        return getRuleContext(TfootContext.class,i);
8645                }
8646                public List<PTagOpenContext> pTagOpen() {
8647                        return getRuleContexts(PTagOpenContext.class);
8648                }
8649                public PTagOpenContext pTagOpen(int i) {
8650                        return getRuleContext(PTagOpenContext.class,i);
8651                }
8652                public List<LiTagOpenContext> liTagOpen() {
8653                        return getRuleContexts(LiTagOpenContext.class);
8654                }
8655                public LiTagOpenContext liTagOpen(int i) {
8656                        return getRuleContext(LiTagOpenContext.class,i);
8657                }
8658                public List<TrTagOpenContext> trTagOpen() {
8659                        return getRuleContexts(TrTagOpenContext.class);
8660                }
8661                public TrTagOpenContext trTagOpen(int i) {
8662                        return getRuleContext(TrTagOpenContext.class,i);
8663                }
8664                public List<TdTagOpenContext> tdTagOpen() {
8665                        return getRuleContexts(TdTagOpenContext.class);
8666                }
8667                public TdTagOpenContext tdTagOpen(int i) {
8668                        return getRuleContext(TdTagOpenContext.class,i);
8669                }
8670                public List<ThTagOpenContext> thTagOpen() {
8671                        return getRuleContexts(ThTagOpenContext.class);
8672                }
8673                public ThTagOpenContext thTagOpen(int i) {
8674                        return getRuleContext(ThTagOpenContext.class,i);
8675                }
8676                public List<BodyTagOpenContext> bodyTagOpen() {
8677                        return getRuleContexts(BodyTagOpenContext.class);
8678                }
8679                public BodyTagOpenContext bodyTagOpen(int i) {
8680                        return getRuleContext(BodyTagOpenContext.class,i);
8681                }
8682                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8683                        return getRuleContexts(ColgroupTagOpenContext.class);
8684                }
8685                public ColgroupTagOpenContext colgroupTagOpen(int i) {
8686                        return getRuleContext(ColgroupTagOpenContext.class,i);
8687                }
8688                public List<DdTagOpenContext> ddTagOpen() {
8689                        return getRuleContexts(DdTagOpenContext.class);
8690                }
8691                public DdTagOpenContext ddTagOpen(int i) {
8692                        return getRuleContext(DdTagOpenContext.class,i);
8693                }
8694                public List<DtTagOpenContext> dtTagOpen() {
8695                        return getRuleContexts(DtTagOpenContext.class);
8696                }
8697                public DtTagOpenContext dtTagOpen(int i) {
8698                        return getRuleContext(DtTagOpenContext.class,i);
8699                }
8700                public List<HeadTagOpenContext> headTagOpen() {
8701                        return getRuleContexts(HeadTagOpenContext.class);
8702                }
8703                public HeadTagOpenContext headTagOpen(int i) {
8704                        return getRuleContext(HeadTagOpenContext.class,i);
8705                }
8706                public List<OptionTagOpenContext> optionTagOpen() {
8707                        return getRuleContexts(OptionTagOpenContext.class);
8708                }
8709                public OptionTagOpenContext optionTagOpen(int i) {
8710                        return getRuleContext(OptionTagOpenContext.class,i);
8711                }
8712                public List<TbodyTagOpenContext> tbodyTagOpen() {
8713                        return getRuleContexts(TbodyTagOpenContext.class);
8714                }
8715                public TbodyTagOpenContext tbodyTagOpen(int i) {
8716                        return getRuleContext(TbodyTagOpenContext.class,i);
8717                }
8718                public List<TheadTagOpenContext> theadTagOpen() {
8719                        return getRuleContexts(TheadTagOpenContext.class);
8720                }
8721                public TheadTagOpenContext theadTagOpen(int i) {
8722                        return getRuleContext(TheadTagOpenContext.class,i);
8723                }
8724                public List<TfootTagOpenContext> tfootTagOpen() {
8725                        return getRuleContexts(TfootTagOpenContext.class);
8726                }
8727                public TfootTagOpenContext tfootTagOpen(int i) {
8728                        return getRuleContext(TfootTagOpenContext.class,i);
8729                }
8730                public List<HtmlCommentContext> htmlComment() {
8731                        return getRuleContexts(HtmlCommentContext.class);
8732                }
8733                public HtmlCommentContext htmlComment(int i) {
8734                        return getRuleContext(HtmlCommentContext.class,i);
8735                }
8736                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8737                public TerminalNode CDATA(int i) {
8738                        return getToken(JavadocParser.CDATA, i);
8739                }
8740                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8741                public TerminalNode NEWLINE(int i) {
8742                        return getToken(JavadocParser.NEWLINE, i);
8743                }
8744                public List<TextContext> text() {
8745                        return getRuleContexts(TextContext.class);
8746                }
8747                public TextContext text(int i) {
8748                        return getRuleContext(TextContext.class,i);
8749                }
8750                public List<JavadocInlineTagContext> javadocInlineTag() {
8751                        return getRuleContexts(JavadocInlineTagContext.class);
8752                }
8753                public JavadocInlineTagContext javadocInlineTag(int i) {
8754                        return getRuleContext(JavadocInlineTagContext.class,i);
8755                }
8756                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8757                public TerminalNode LEADING_ASTERISK(int i) {
8758                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8759                }
8760                public HtmlContext(ParserRuleContext parent, int invokingState) {
8761                        super(parent, invokingState);
8762                }
8763                @Override public int getRuleIndex() { return RULE_html; }
8764                @Override
8765                public void enterRule(ParseTreeListener listener) {
8766                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this);
8767                }
8768                @Override
8769                public void exitRule(ParseTreeListener listener) {
8770                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this);
8771                }
8772                @Override
8773                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8774                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this);
8775                        else return visitor.visitChildren(this);
8776                }
8777        }
8778
8779        public final HtmlContext html() throws RecognitionException {
8780                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8781                enterRule(_localctx, 76, RULE_html);
8782                try {
8783                        int _alt;
8784                        enterOuterAlt(_localctx, 1);
8785                        {
8786                        setState(1020);
8787                        htmlTagOpen();
8788                        setState(1060);
8789                        _errHandler.sync(this);
8790                        _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8791                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8792                                if ( _alt==1 ) {
8793                                        {
8794                                        setState(1058);
8795                                        _errHandler.sync(this);
8796                                        switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
8797                                        case 1:
8798                                                {
8799                                                setState(1021);
8800                                                htmlTag();
8801                                                }
8802                                                break;
8803                                        case 2:
8804                                                {
8805                                                setState(1022);
8806                                                singletonTag();
8807                                                }
8808                                                break;
8809                                        case 3:
8810                                                {
8811                                                setState(1023);
8812                                                paragraph();
8813                                                }
8814                                                break;
8815                                        case 4:
8816                                                {
8817                                                setState(1024);
8818                                                li();
8819                                                }
8820                                                break;
8821                                        case 5:
8822                                                {
8823                                                setState(1025);
8824                                                tr();
8825                                                }
8826                                                break;
8827                                        case 6:
8828                                                {
8829                                                setState(1026);
8830                                                td();
8831                                                }
8832                                                break;
8833                                        case 7:
8834                                                {
8835                                                setState(1027);
8836                                                th();
8837                                                }
8838                                                break;
8839                                        case 8:
8840                                                {
8841                                                setState(1028);
8842                                                body();
8843                                                }
8844                                                break;
8845                                        case 9:
8846                                                {
8847                                                setState(1029);
8848                                                colgroup();
8849                                                }
8850                                                break;
8851                                        case 10:
8852                                                {
8853                                                setState(1030);
8854                                                dd();
8855                                                }
8856                                                break;
8857                                        case 11:
8858                                                {
8859                                                setState(1031);
8860                                                dt();
8861                                                }
8862                                                break;
8863                                        case 12:
8864                                                {
8865                                                setState(1032);
8866                                                head();
8867                                                }
8868                                                break;
8869                                        case 13:
8870                                                {
8871                                                setState(1033);
8872                                                option();
8873                                                }
8874                                                break;
8875                                        case 14:
8876                                                {
8877                                                setState(1034);
8878                                                tbody();
8879                                                }
8880                                                break;
8881                                        case 15:
8882                                                {
8883                                                setState(1035);
8884                                                thead();
8885                                                }
8886                                                break;
8887                                        case 16:
8888                                                {
8889                                                setState(1036);
8890                                                tfoot();
8891                                                }
8892                                                break;
8893                                        case 17:
8894                                                {
8895                                                setState(1037);
8896                                                pTagOpen();
8897                                                }
8898                                                break;
8899                                        case 18:
8900                                                {
8901                                                setState(1038);
8902                                                liTagOpen();
8903                                                }
8904                                                break;
8905                                        case 19:
8906                                                {
8907                                                setState(1039);
8908                                                trTagOpen();
8909                                                }
8910                                                break;
8911                                        case 20:
8912                                                {
8913                                                setState(1040);
8914                                                tdTagOpen();
8915                                                }
8916                                                break;
8917                                        case 21:
8918                                                {
8919                                                setState(1041);
8920                                                thTagOpen();
8921                                                }
8922                                                break;
8923                                        case 22:
8924                                                {
8925                                                setState(1042);
8926                                                bodyTagOpen();
8927                                                }
8928                                                break;
8929                                        case 23:
8930                                                {
8931                                                setState(1043);
8932                                                colgroupTagOpen();
8933                                                }
8934                                                break;
8935                                        case 24:
8936                                                {
8937                                                setState(1044);
8938                                                ddTagOpen();
8939                                                }
8940                                                break;
8941                                        case 25:
8942                                                {
8943                                                setState(1045);
8944                                                dtTagOpen();
8945                                                }
8946                                                break;
8947                                        case 26:
8948                                                {
8949                                                setState(1046);
8950                                                headTagOpen();
8951                                                }
8952                                                break;
8953                                        case 27:
8954                                                {
8955                                                setState(1047);
8956                                                optionTagOpen();
8957                                                }
8958                                                break;
8959                                        case 28:
8960                                                {
8961                                                setState(1048);
8962                                                tbodyTagOpen();
8963                                                }
8964                                                break;
8965                                        case 29:
8966                                                {
8967                                                setState(1049);
8968                                                theadTagOpen();
8969                                                }
8970                                                break;
8971                                        case 30:
8972                                                {
8973                                                setState(1050);
8974                                                tfootTagOpen();
8975                                                }
8976                                                break;
8977                                        case 31:
8978                                                {
8979                                                {
8980                                                setState(1051);
8981                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8982                                                setState(1052);
8983                                                match(LEADING_ASTERISK);
8984                                                }
8985                                                }
8986                                                break;
8987                                        case 32:
8988                                                {
8989                                                setState(1053);
8990                                                htmlComment();
8991                                                }
8992                                                break;
8993                                        case 33:
8994                                                {
8995                                                setState(1054);
8996                                                match(CDATA);
8997                                                }
8998                                                break;
8999                                        case 34:
9000                                                {
9001                                                setState(1055);
9002                                                match(NEWLINE);
9003                                                }
9004                                                break;
9005                                        case 35:
9006                                                {
9007                                                setState(1056);
9008                                                text();
9009                                                }
9010                                                break;
9011                                        case 36:
9012                                                {
9013                                                setState(1057);
9014                                                javadocInlineTag();
9015                                                }
9016                                                break;
9017                                        }
9018                                        } 
9019                                }
9020                                setState(1062);
9021                                _errHandler.sync(this);
9022                                _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
9023                        }
9024                        setState(1063);
9025                        htmlTagClose();
9026                        }
9027                }
9028                catch (RecognitionException re) {
9029                        _localctx.exception = re;
9030                        _errHandler.reportError(this, re);
9031                        _errHandler.recover(this, re);
9032                }
9033                finally {
9034                        exitRule();
9035                }
9036                return _localctx;
9037        }
9038
9039        public static class OptionTagOpenContext extends ParserRuleContext {
9040                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9041                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9042                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9043                public List<AttributeContext> attribute() {
9044                        return getRuleContexts(AttributeContext.class);
9045                }
9046                public AttributeContext attribute(int i) {
9047                        return getRuleContext(AttributeContext.class,i);
9048                }
9049                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9050                public TerminalNode NEWLINE(int i) {
9051                        return getToken(JavadocParser.NEWLINE, i);
9052                }
9053                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9054                public TerminalNode LEADING_ASTERISK(int i) {
9055                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9056                }
9057                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9058                public TerminalNode WS(int i) {
9059                        return getToken(JavadocParser.WS, i);
9060                }
9061                public OptionTagOpenContext(ParserRuleContext parent, int invokingState) {
9062                        super(parent, invokingState);
9063                }
9064                @Override public int getRuleIndex() { return RULE_optionTagOpen; }
9065                @Override
9066                public void enterRule(ParseTreeListener listener) {
9067                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this);
9068                }
9069                @Override
9070                public void exitRule(ParseTreeListener listener) {
9071                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this);
9072                }
9073                @Override
9074                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9075                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this);
9076                        else return visitor.visitChildren(this);
9077                }
9078        }
9079
9080        public final OptionTagOpenContext optionTagOpen() throws RecognitionException {
9081                OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState());
9082                enterRule(_localctx, 78, RULE_optionTagOpen);
9083                int _la;
9084                try {
9085                        enterOuterAlt(_localctx, 1);
9086                        {
9087                        setState(1065);
9088                        match(OPEN);
9089                        setState(1066);
9090                        match(OPTION_HTML_TAG_NAME);
9091                        setState(1073);
9092                        _errHandler.sync(this);
9093                        _la = _input.LA(1);
9094                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9095                                {
9096                                setState(1071);
9097                                _errHandler.sync(this);
9098                                switch (_input.LA(1)) {
9099                                case HTML_TAG_NAME:
9100                                        {
9101                                        setState(1067);
9102                                        attribute();
9103                                        }
9104                                        break;
9105                                case NEWLINE:
9106                                        {
9107                                        setState(1068);
9108                                        match(NEWLINE);
9109                                        }
9110                                        break;
9111                                case LEADING_ASTERISK:
9112                                        {
9113                                        setState(1069);
9114                                        match(LEADING_ASTERISK);
9115                                        }
9116                                        break;
9117                                case WS:
9118                                        {
9119                                        setState(1070);
9120                                        match(WS);
9121                                        }
9122                                        break;
9123                                default:
9124                                        throw new NoViableAltException(this);
9125                                }
9126                                }
9127                                setState(1075);
9128                                _errHandler.sync(this);
9129                                _la = _input.LA(1);
9130                        }
9131                        setState(1076);
9132                        match(CLOSE);
9133                        }
9134                }
9135                catch (RecognitionException re) {
9136                        _localctx.exception = re;
9137                        _errHandler.reportError(this, re);
9138                        _errHandler.recover(this, re);
9139                }
9140                finally {
9141                        exitRule();
9142                }
9143                return _localctx;
9144        }
9145
9146        public static class OptionTagCloseContext extends ParserRuleContext {
9147                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9148                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9149                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9150                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9151                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9152                public TerminalNode NEWLINE(int i) {
9153                        return getToken(JavadocParser.NEWLINE, i);
9154                }
9155                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9156                public TerminalNode LEADING_ASTERISK(int i) {
9157                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9158                }
9159                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9160                public TerminalNode WS(int i) {
9161                        return getToken(JavadocParser.WS, i);
9162                }
9163                public OptionTagCloseContext(ParserRuleContext parent, int invokingState) {
9164                        super(parent, invokingState);
9165                }
9166                @Override public int getRuleIndex() { return RULE_optionTagClose; }
9167                @Override
9168                public void enterRule(ParseTreeListener listener) {
9169                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this);
9170                }
9171                @Override
9172                public void exitRule(ParseTreeListener listener) {
9173                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this);
9174                }
9175                @Override
9176                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9177                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this);
9178                        else return visitor.visitChildren(this);
9179                }
9180        }
9181
9182        public final OptionTagCloseContext optionTagClose() throws RecognitionException {
9183                OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState());
9184                enterRule(_localctx, 80, RULE_optionTagClose);
9185                int _la;
9186                try {
9187                        enterOuterAlt(_localctx, 1);
9188                        {
9189                        setState(1078);
9190                        match(OPEN);
9191                        setState(1079);
9192                        match(SLASH);
9193                        setState(1080);
9194                        match(OPTION_HTML_TAG_NAME);
9195                        setState(1084);
9196                        _errHandler.sync(this);
9197                        _la = _input.LA(1);
9198                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9199                                {
9200                                {
9201                                setState(1081);
9202                                _la = _input.LA(1);
9203                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9204                                _errHandler.recoverInline(this);
9205                                }
9206                                else {
9207                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
9208                                        _errHandler.reportMatch(this);
9209                                        consume();
9210                                }
9211                                }
9212                                }
9213                                setState(1086);
9214                                _errHandler.sync(this);
9215                                _la = _input.LA(1);
9216                        }
9217                        setState(1087);
9218                        match(CLOSE);
9219                        }
9220                }
9221                catch (RecognitionException re) {
9222                        _localctx.exception = re;
9223                        _errHandler.reportError(this, re);
9224                        _errHandler.recover(this, re);
9225                }
9226                finally {
9227                        exitRule();
9228                }
9229                return _localctx;
9230        }
9231
9232        public static class OptionContext extends ParserRuleContext {
9233                public OptionTagOpenContext optionTagOpen() {
9234                        return getRuleContext(OptionTagOpenContext.class,0);
9235                }
9236                public OptionTagCloseContext optionTagClose() {
9237                        return getRuleContext(OptionTagCloseContext.class,0);
9238                }
9239                public List<HtmlTagContext> htmlTag() {
9240                        return getRuleContexts(HtmlTagContext.class);
9241                }
9242                public HtmlTagContext htmlTag(int i) {
9243                        return getRuleContext(HtmlTagContext.class,i);
9244                }
9245                public List<SingletonTagContext> singletonTag() {
9246                        return getRuleContexts(SingletonTagContext.class);
9247                }
9248                public SingletonTagContext singletonTag(int i) {
9249                        return getRuleContext(SingletonTagContext.class,i);
9250                }
9251                public List<ParagraphContext> paragraph() {
9252                        return getRuleContexts(ParagraphContext.class);
9253                }
9254                public ParagraphContext paragraph(int i) {
9255                        return getRuleContext(ParagraphContext.class,i);
9256                }
9257                public List<LiContext> li() {
9258                        return getRuleContexts(LiContext.class);
9259                }
9260                public LiContext li(int i) {
9261                        return getRuleContext(LiContext.class,i);
9262                }
9263                public List<TrContext> tr() {
9264                        return getRuleContexts(TrContext.class);
9265                }
9266                public TrContext tr(int i) {
9267                        return getRuleContext(TrContext.class,i);
9268                }
9269                public List<TdContext> td() {
9270                        return getRuleContexts(TdContext.class);
9271                }
9272                public TdContext td(int i) {
9273                        return getRuleContext(TdContext.class,i);
9274                }
9275                public List<ThContext> th() {
9276                        return getRuleContexts(ThContext.class);
9277                }
9278                public ThContext th(int i) {
9279                        return getRuleContext(ThContext.class,i);
9280                }
9281                public List<BodyContext> body() {
9282                        return getRuleContexts(BodyContext.class);
9283                }
9284                public BodyContext body(int i) {
9285                        return getRuleContext(BodyContext.class,i);
9286                }
9287                public List<ColgroupContext> colgroup() {
9288                        return getRuleContexts(ColgroupContext.class);
9289                }
9290                public ColgroupContext colgroup(int i) {
9291                        return getRuleContext(ColgroupContext.class,i);
9292                }
9293                public List<DdContext> dd() {
9294                        return getRuleContexts(DdContext.class);
9295                }
9296                public DdContext dd(int i) {
9297                        return getRuleContext(DdContext.class,i);
9298                }
9299                public List<DtContext> dt() {
9300                        return getRuleContexts(DtContext.class);
9301                }
9302                public DtContext dt(int i) {
9303                        return getRuleContext(DtContext.class,i);
9304                }
9305                public List<HeadContext> head() {
9306                        return getRuleContexts(HeadContext.class);
9307                }
9308                public HeadContext head(int i) {
9309                        return getRuleContext(HeadContext.class,i);
9310                }
9311                public List<HtmlContext> html() {
9312                        return getRuleContexts(HtmlContext.class);
9313                }
9314                public HtmlContext html(int i) {
9315                        return getRuleContext(HtmlContext.class,i);
9316                }
9317                public List<TbodyContext> tbody() {
9318                        return getRuleContexts(TbodyContext.class);
9319                }
9320                public TbodyContext tbody(int i) {
9321                        return getRuleContext(TbodyContext.class,i);
9322                }
9323                public List<TheadContext> thead() {
9324                        return getRuleContexts(TheadContext.class);
9325                }
9326                public TheadContext thead(int i) {
9327                        return getRuleContext(TheadContext.class,i);
9328                }
9329                public List<TfootContext> tfoot() {
9330                        return getRuleContexts(TfootContext.class);
9331                }
9332                public TfootContext tfoot(int i) {
9333                        return getRuleContext(TfootContext.class,i);
9334                }
9335                public List<PTagOpenContext> pTagOpen() {
9336                        return getRuleContexts(PTagOpenContext.class);
9337                }
9338                public PTagOpenContext pTagOpen(int i) {
9339                        return getRuleContext(PTagOpenContext.class,i);
9340                }
9341                public List<LiTagOpenContext> liTagOpen() {
9342                        return getRuleContexts(LiTagOpenContext.class);
9343                }
9344                public LiTagOpenContext liTagOpen(int i) {
9345                        return getRuleContext(LiTagOpenContext.class,i);
9346                }
9347                public List<TrTagOpenContext> trTagOpen() {
9348                        return getRuleContexts(TrTagOpenContext.class);
9349                }
9350                public TrTagOpenContext trTagOpen(int i) {
9351                        return getRuleContext(TrTagOpenContext.class,i);
9352                }
9353                public List<TdTagOpenContext> tdTagOpen() {
9354                        return getRuleContexts(TdTagOpenContext.class);
9355                }
9356                public TdTagOpenContext tdTagOpen(int i) {
9357                        return getRuleContext(TdTagOpenContext.class,i);
9358                }
9359                public List<ThTagOpenContext> thTagOpen() {
9360                        return getRuleContexts(ThTagOpenContext.class);
9361                }
9362                public ThTagOpenContext thTagOpen(int i) {
9363                        return getRuleContext(ThTagOpenContext.class,i);
9364                }
9365                public List<BodyTagOpenContext> bodyTagOpen() {
9366                        return getRuleContexts(BodyTagOpenContext.class);
9367                }
9368                public BodyTagOpenContext bodyTagOpen(int i) {
9369                        return getRuleContext(BodyTagOpenContext.class,i);
9370                }
9371                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9372                        return getRuleContexts(ColgroupTagOpenContext.class);
9373                }
9374                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9375                        return getRuleContext(ColgroupTagOpenContext.class,i);
9376                }
9377                public List<DdTagOpenContext> ddTagOpen() {
9378                        return getRuleContexts(DdTagOpenContext.class);
9379                }
9380                public DdTagOpenContext ddTagOpen(int i) {
9381                        return getRuleContext(DdTagOpenContext.class,i);
9382                }
9383                public List<DtTagOpenContext> dtTagOpen() {
9384                        return getRuleContexts(DtTagOpenContext.class);
9385                }
9386                public DtTagOpenContext dtTagOpen(int i) {
9387                        return getRuleContext(DtTagOpenContext.class,i);
9388                }
9389                public List<HeadTagOpenContext> headTagOpen() {
9390                        return getRuleContexts(HeadTagOpenContext.class);
9391                }
9392                public HeadTagOpenContext headTagOpen(int i) {
9393                        return getRuleContext(HeadTagOpenContext.class,i);
9394                }
9395                public List<HtmlTagOpenContext> htmlTagOpen() {
9396                        return getRuleContexts(HtmlTagOpenContext.class);
9397                }
9398                public HtmlTagOpenContext htmlTagOpen(int i) {
9399                        return getRuleContext(HtmlTagOpenContext.class,i);
9400                }
9401                public List<TbodyTagOpenContext> tbodyTagOpen() {
9402                        return getRuleContexts(TbodyTagOpenContext.class);
9403                }
9404                public TbodyTagOpenContext tbodyTagOpen(int i) {
9405                        return getRuleContext(TbodyTagOpenContext.class,i);
9406                }
9407                public List<TheadTagOpenContext> theadTagOpen() {
9408                        return getRuleContexts(TheadTagOpenContext.class);
9409                }
9410                public TheadTagOpenContext theadTagOpen(int i) {
9411                        return getRuleContext(TheadTagOpenContext.class,i);
9412                }
9413                public List<TfootTagOpenContext> tfootTagOpen() {
9414                        return getRuleContexts(TfootTagOpenContext.class);
9415                }
9416                public TfootTagOpenContext tfootTagOpen(int i) {
9417                        return getRuleContext(TfootTagOpenContext.class,i);
9418                }
9419                public List<HtmlCommentContext> htmlComment() {
9420                        return getRuleContexts(HtmlCommentContext.class);
9421                }
9422                public HtmlCommentContext htmlComment(int i) {
9423                        return getRuleContext(HtmlCommentContext.class,i);
9424                }
9425                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9426                public TerminalNode CDATA(int i) {
9427                        return getToken(JavadocParser.CDATA, i);
9428                }
9429                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9430                public TerminalNode NEWLINE(int i) {
9431                        return getToken(JavadocParser.NEWLINE, i);
9432                }
9433                public List<TextContext> text() {
9434                        return getRuleContexts(TextContext.class);
9435                }
9436                public TextContext text(int i) {
9437                        return getRuleContext(TextContext.class,i);
9438                }
9439                public List<JavadocInlineTagContext> javadocInlineTag() {
9440                        return getRuleContexts(JavadocInlineTagContext.class);
9441                }
9442                public JavadocInlineTagContext javadocInlineTag(int i) {
9443                        return getRuleContext(JavadocInlineTagContext.class,i);
9444                }
9445                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9446                public TerminalNode LEADING_ASTERISK(int i) {
9447                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9448                }
9449                public OptionContext(ParserRuleContext parent, int invokingState) {
9450                        super(parent, invokingState);
9451                }
9452                @Override public int getRuleIndex() { return RULE_option; }
9453                @Override
9454                public void enterRule(ParseTreeListener listener) {
9455                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this);
9456                }
9457                @Override
9458                public void exitRule(ParseTreeListener listener) {
9459                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this);
9460                }
9461                @Override
9462                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9463                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this);
9464                        else return visitor.visitChildren(this);
9465                }
9466        }
9467
9468        public final OptionContext option() throws RecognitionException {
9469                OptionContext _localctx = new OptionContext(_ctx, getState());
9470                enterRule(_localctx, 82, RULE_option);
9471                try {
9472                        int _alt;
9473                        enterOuterAlt(_localctx, 1);
9474                        {
9475                        setState(1089);
9476                        optionTagOpen();
9477                        setState(1129);
9478                        _errHandler.sync(this);
9479                        _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9480                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9481                                if ( _alt==1 ) {
9482                                        {
9483                                        setState(1127);
9484                                        _errHandler.sync(this);
9485                                        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
9486                                        case 1:
9487                                                {
9488                                                setState(1090);
9489                                                htmlTag();
9490                                                }
9491                                                break;
9492                                        case 2:
9493                                                {
9494                                                setState(1091);
9495                                                singletonTag();
9496                                                }
9497                                                break;
9498                                        case 3:
9499                                                {
9500                                                setState(1092);
9501                                                paragraph();
9502                                                }
9503                                                break;
9504                                        case 4:
9505                                                {
9506                                                setState(1093);
9507                                                li();
9508                                                }
9509                                                break;
9510                                        case 5:
9511                                                {
9512                                                setState(1094);
9513                                                tr();
9514                                                }
9515                                                break;
9516                                        case 6:
9517                                                {
9518                                                setState(1095);
9519                                                td();
9520                                                }
9521                                                break;
9522                                        case 7:
9523                                                {
9524                                                setState(1096);
9525                                                th();
9526                                                }
9527                                                break;
9528                                        case 8:
9529                                                {
9530                                                setState(1097);
9531                                                body();
9532                                                }
9533                                                break;
9534                                        case 9:
9535                                                {
9536                                                setState(1098);
9537                                                colgroup();
9538                                                }
9539                                                break;
9540                                        case 10:
9541                                                {
9542                                                setState(1099);
9543                                                dd();
9544                                                }
9545                                                break;
9546                                        case 11:
9547                                                {
9548                                                setState(1100);
9549                                                dt();
9550                                                }
9551                                                break;
9552                                        case 12:
9553                                                {
9554                                                setState(1101);
9555                                                head();
9556                                                }
9557                                                break;
9558                                        case 13:
9559                                                {
9560                                                setState(1102);
9561                                                html();
9562                                                }
9563                                                break;
9564                                        case 14:
9565                                                {
9566                                                setState(1103);
9567                                                tbody();
9568                                                }
9569                                                break;
9570                                        case 15:
9571                                                {
9572                                                setState(1104);
9573                                                thead();
9574                                                }
9575                                                break;
9576                                        case 16:
9577                                                {
9578                                                setState(1105);
9579                                                tfoot();
9580                                                }
9581                                                break;
9582                                        case 17:
9583                                                {
9584                                                setState(1106);
9585                                                pTagOpen();
9586                                                }
9587                                                break;
9588                                        case 18:
9589                                                {
9590                                                setState(1107);
9591                                                liTagOpen();
9592                                                }
9593                                                break;
9594                                        case 19:
9595                                                {
9596                                                setState(1108);
9597                                                trTagOpen();
9598                                                }
9599                                                break;
9600                                        case 20:
9601                                                {
9602                                                setState(1109);
9603                                                tdTagOpen();
9604                                                }
9605                                                break;
9606                                        case 21:
9607                                                {
9608                                                setState(1110);
9609                                                thTagOpen();
9610                                                }
9611                                                break;
9612                                        case 22:
9613                                                {
9614                                                setState(1111);
9615                                                bodyTagOpen();
9616                                                }
9617                                                break;
9618                                        case 23:
9619                                                {
9620                                                setState(1112);
9621                                                colgroupTagOpen();
9622                                                }
9623                                                break;
9624                                        case 24:
9625                                                {
9626                                                setState(1113);
9627                                                ddTagOpen();
9628                                                }
9629                                                break;
9630                                        case 25:
9631                                                {
9632                                                setState(1114);
9633                                                dtTagOpen();
9634                                                }
9635                                                break;
9636                                        case 26:
9637                                                {
9638                                                setState(1115);
9639                                                headTagOpen();
9640                                                }
9641                                                break;
9642                                        case 27:
9643                                                {
9644                                                setState(1116);
9645                                                htmlTagOpen();
9646                                                }
9647                                                break;
9648                                        case 28:
9649                                                {
9650                                                setState(1117);
9651                                                tbodyTagOpen();
9652                                                }
9653                                                break;
9654                                        case 29:
9655                                                {
9656                                                setState(1118);
9657                                                theadTagOpen();
9658                                                }
9659                                                break;
9660                                        case 30:
9661                                                {
9662                                                setState(1119);
9663                                                tfootTagOpen();
9664                                                }
9665                                                break;
9666                                        case 31:
9667                                                {
9668                                                {
9669                                                setState(1120);
9670                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9671                                                setState(1121);
9672                                                match(LEADING_ASTERISK);
9673                                                }
9674                                                }
9675                                                break;
9676                                        case 32:
9677                                                {
9678                                                setState(1122);
9679                                                htmlComment();
9680                                                }
9681                                                break;
9682                                        case 33:
9683                                                {
9684                                                setState(1123);
9685                                                match(CDATA);
9686                                                }
9687                                                break;
9688                                        case 34:
9689                                                {
9690                                                setState(1124);
9691                                                match(NEWLINE);
9692                                                }
9693                                                break;
9694                                        case 35:
9695                                                {
9696                                                setState(1125);
9697                                                text();
9698                                                }
9699                                                break;
9700                                        case 36:
9701                                                {
9702                                                setState(1126);
9703                                                javadocInlineTag();
9704                                                }
9705                                                break;
9706                                        }
9707                                        } 
9708                                }
9709                                setState(1131);
9710                                _errHandler.sync(this);
9711                                _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9712                        }
9713                        setState(1132);
9714                        optionTagClose();
9715                        }
9716                }
9717                catch (RecognitionException re) {
9718                        _localctx.exception = re;
9719                        _errHandler.reportError(this, re);
9720                        _errHandler.recover(this, re);
9721                }
9722                finally {
9723                        exitRule();
9724                }
9725                return _localctx;
9726        }
9727
9728        public static class TbodyTagOpenContext extends ParserRuleContext {
9729                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9730                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9731                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9732                public List<AttributeContext> attribute() {
9733                        return getRuleContexts(AttributeContext.class);
9734                }
9735                public AttributeContext attribute(int i) {
9736                        return getRuleContext(AttributeContext.class,i);
9737                }
9738                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9739                public TerminalNode NEWLINE(int i) {
9740                        return getToken(JavadocParser.NEWLINE, i);
9741                }
9742                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9743                public TerminalNode LEADING_ASTERISK(int i) {
9744                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9745                }
9746                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9747                public TerminalNode WS(int i) {
9748                        return getToken(JavadocParser.WS, i);
9749                }
9750                public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) {
9751                        super(parent, invokingState);
9752                }
9753                @Override public int getRuleIndex() { return RULE_tbodyTagOpen; }
9754                @Override
9755                public void enterRule(ParseTreeListener listener) {
9756                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this);
9757                }
9758                @Override
9759                public void exitRule(ParseTreeListener listener) {
9760                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this);
9761                }
9762                @Override
9763                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9764                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this);
9765                        else return visitor.visitChildren(this);
9766                }
9767        }
9768
9769        public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException {
9770                TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState());
9771                enterRule(_localctx, 84, RULE_tbodyTagOpen);
9772                int _la;
9773                try {
9774                        enterOuterAlt(_localctx, 1);
9775                        {
9776                        setState(1134);
9777                        match(OPEN);
9778                        setState(1135);
9779                        match(TBODY_HTML_TAG_NAME);
9780                        setState(1142);
9781                        _errHandler.sync(this);
9782                        _la = _input.LA(1);
9783                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9784                                {
9785                                setState(1140);
9786                                _errHandler.sync(this);
9787                                switch (_input.LA(1)) {
9788                                case HTML_TAG_NAME:
9789                                        {
9790                                        setState(1136);
9791                                        attribute();
9792                                        }
9793                                        break;
9794                                case NEWLINE:
9795                                        {
9796                                        setState(1137);
9797                                        match(NEWLINE);
9798                                        }
9799                                        break;
9800                                case LEADING_ASTERISK:
9801                                        {
9802                                        setState(1138);
9803                                        match(LEADING_ASTERISK);
9804                                        }
9805                                        break;
9806                                case WS:
9807                                        {
9808                                        setState(1139);
9809                                        match(WS);
9810                                        }
9811                                        break;
9812                                default:
9813                                        throw new NoViableAltException(this);
9814                                }
9815                                }
9816                                setState(1144);
9817                                _errHandler.sync(this);
9818                                _la = _input.LA(1);
9819                        }
9820                        setState(1145);
9821                        match(CLOSE);
9822                        }
9823                }
9824                catch (RecognitionException re) {
9825                        _localctx.exception = re;
9826                        _errHandler.reportError(this, re);
9827                        _errHandler.recover(this, re);
9828                }
9829                finally {
9830                        exitRule();
9831                }
9832                return _localctx;
9833        }
9834
9835        public static class TbodyTagCloseContext extends ParserRuleContext {
9836                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9837                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9838                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9839                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9840                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9841                public TerminalNode NEWLINE(int i) {
9842                        return getToken(JavadocParser.NEWLINE, i);
9843                }
9844                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9845                public TerminalNode LEADING_ASTERISK(int i) {
9846                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9847                }
9848                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9849                public TerminalNode WS(int i) {
9850                        return getToken(JavadocParser.WS, i);
9851                }
9852                public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) {
9853                        super(parent, invokingState);
9854                }
9855                @Override public int getRuleIndex() { return RULE_tbodyTagClose; }
9856                @Override
9857                public void enterRule(ParseTreeListener listener) {
9858                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this);
9859                }
9860                @Override
9861                public void exitRule(ParseTreeListener listener) {
9862                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this);
9863                }
9864                @Override
9865                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9866                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this);
9867                        else return visitor.visitChildren(this);
9868                }
9869        }
9870
9871        public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException {
9872                TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState());
9873                enterRule(_localctx, 86, RULE_tbodyTagClose);
9874                int _la;
9875                try {
9876                        enterOuterAlt(_localctx, 1);
9877                        {
9878                        setState(1147);
9879                        match(OPEN);
9880                        setState(1148);
9881                        match(SLASH);
9882                        setState(1149);
9883                        match(TBODY_HTML_TAG_NAME);
9884                        setState(1153);
9885                        _errHandler.sync(this);
9886                        _la = _input.LA(1);
9887                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9888                                {
9889                                {
9890                                setState(1150);
9891                                _la = _input.LA(1);
9892                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9893                                _errHandler.recoverInline(this);
9894                                }
9895                                else {
9896                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
9897                                        _errHandler.reportMatch(this);
9898                                        consume();
9899                                }
9900                                }
9901                                }
9902                                setState(1155);
9903                                _errHandler.sync(this);
9904                                _la = _input.LA(1);
9905                        }
9906                        setState(1156);
9907                        match(CLOSE);
9908                        }
9909                }
9910                catch (RecognitionException re) {
9911                        _localctx.exception = re;
9912                        _errHandler.reportError(this, re);
9913                        _errHandler.recover(this, re);
9914                }
9915                finally {
9916                        exitRule();
9917                }
9918                return _localctx;
9919        }
9920
9921        public static class TbodyContext extends ParserRuleContext {
9922                public TbodyTagOpenContext tbodyTagOpen() {
9923                        return getRuleContext(TbodyTagOpenContext.class,0);
9924                }
9925                public TbodyTagCloseContext tbodyTagClose() {
9926                        return getRuleContext(TbodyTagCloseContext.class,0);
9927                }
9928                public List<HtmlTagContext> htmlTag() {
9929                        return getRuleContexts(HtmlTagContext.class);
9930                }
9931                public HtmlTagContext htmlTag(int i) {
9932                        return getRuleContext(HtmlTagContext.class,i);
9933                }
9934                public List<SingletonTagContext> singletonTag() {
9935                        return getRuleContexts(SingletonTagContext.class);
9936                }
9937                public SingletonTagContext singletonTag(int i) {
9938                        return getRuleContext(SingletonTagContext.class,i);
9939                }
9940                public List<ParagraphContext> paragraph() {
9941                        return getRuleContexts(ParagraphContext.class);
9942                }
9943                public ParagraphContext paragraph(int i) {
9944                        return getRuleContext(ParagraphContext.class,i);
9945                }
9946                public List<LiContext> li() {
9947                        return getRuleContexts(LiContext.class);
9948                }
9949                public LiContext li(int i) {
9950                        return getRuleContext(LiContext.class,i);
9951                }
9952                public List<TrContext> tr() {
9953                        return getRuleContexts(TrContext.class);
9954                }
9955                public TrContext tr(int i) {
9956                        return getRuleContext(TrContext.class,i);
9957                }
9958                public List<TdContext> td() {
9959                        return getRuleContexts(TdContext.class);
9960                }
9961                public TdContext td(int i) {
9962                        return getRuleContext(TdContext.class,i);
9963                }
9964                public List<ThContext> th() {
9965                        return getRuleContexts(ThContext.class);
9966                }
9967                public ThContext th(int i) {
9968                        return getRuleContext(ThContext.class,i);
9969                }
9970                public List<BodyContext> body() {
9971                        return getRuleContexts(BodyContext.class);
9972                }
9973                public BodyContext body(int i) {
9974                        return getRuleContext(BodyContext.class,i);
9975                }
9976                public List<ColgroupContext> colgroup() {
9977                        return getRuleContexts(ColgroupContext.class);
9978                }
9979                public ColgroupContext colgroup(int i) {
9980                        return getRuleContext(ColgroupContext.class,i);
9981                }
9982                public List<DdContext> dd() {
9983                        return getRuleContexts(DdContext.class);
9984                }
9985                public DdContext dd(int i) {
9986                        return getRuleContext(DdContext.class,i);
9987                }
9988                public List<DtContext> dt() {
9989                        return getRuleContexts(DtContext.class);
9990                }
9991                public DtContext dt(int i) {
9992                        return getRuleContext(DtContext.class,i);
9993                }
9994                public List<HeadContext> head() {
9995                        return getRuleContexts(HeadContext.class);
9996                }
9997                public HeadContext head(int i) {
9998                        return getRuleContext(HeadContext.class,i);
9999                }
10000                public List<HtmlContext> html() {
10001                        return getRuleContexts(HtmlContext.class);
10002                }
10003                public HtmlContext html(int i) {
10004                        return getRuleContext(HtmlContext.class,i);
10005                }
10006                public List<OptionContext> option() {
10007                        return getRuleContexts(OptionContext.class);
10008                }
10009                public OptionContext option(int i) {
10010                        return getRuleContext(OptionContext.class,i);
10011                }
10012                public List<TheadContext> thead() {
10013                        return getRuleContexts(TheadContext.class);
10014                }
10015                public TheadContext thead(int i) {
10016                        return getRuleContext(TheadContext.class,i);
10017                }
10018                public List<TfootContext> tfoot() {
10019                        return getRuleContexts(TfootContext.class);
10020                }
10021                public TfootContext tfoot(int i) {
10022                        return getRuleContext(TfootContext.class,i);
10023                }
10024                public List<PTagOpenContext> pTagOpen() {
10025                        return getRuleContexts(PTagOpenContext.class);
10026                }
10027                public PTagOpenContext pTagOpen(int i) {
10028                        return getRuleContext(PTagOpenContext.class,i);
10029                }
10030                public List<LiTagOpenContext> liTagOpen() {
10031                        return getRuleContexts(LiTagOpenContext.class);
10032                }
10033                public LiTagOpenContext liTagOpen(int i) {
10034                        return getRuleContext(LiTagOpenContext.class,i);
10035                }
10036                public List<TrTagOpenContext> trTagOpen() {
10037                        return getRuleContexts(TrTagOpenContext.class);
10038                }
10039                public TrTagOpenContext trTagOpen(int i) {
10040                        return getRuleContext(TrTagOpenContext.class,i);
10041                }
10042                public List<TdTagOpenContext> tdTagOpen() {
10043                        return getRuleContexts(TdTagOpenContext.class);
10044                }
10045                public TdTagOpenContext tdTagOpen(int i) {
10046                        return getRuleContext(TdTagOpenContext.class,i);
10047                }
10048                public List<ThTagOpenContext> thTagOpen() {
10049                        return getRuleContexts(ThTagOpenContext.class);
10050                }
10051                public ThTagOpenContext thTagOpen(int i) {
10052                        return getRuleContext(ThTagOpenContext.class,i);
10053                }
10054                public List<BodyTagOpenContext> bodyTagOpen() {
10055                        return getRuleContexts(BodyTagOpenContext.class);
10056                }
10057                public BodyTagOpenContext bodyTagOpen(int i) {
10058                        return getRuleContext(BodyTagOpenContext.class,i);
10059                }
10060                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10061                        return getRuleContexts(ColgroupTagOpenContext.class);
10062                }
10063                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10064                        return getRuleContext(ColgroupTagOpenContext.class,i);
10065                }
10066                public List<DdTagOpenContext> ddTagOpen() {
10067                        return getRuleContexts(DdTagOpenContext.class);
10068                }
10069                public DdTagOpenContext ddTagOpen(int i) {
10070                        return getRuleContext(DdTagOpenContext.class,i);
10071                }
10072                public List<DtTagOpenContext> dtTagOpen() {
10073                        return getRuleContexts(DtTagOpenContext.class);
10074                }
10075                public DtTagOpenContext dtTagOpen(int i) {
10076                        return getRuleContext(DtTagOpenContext.class,i);
10077                }
10078                public List<HeadTagOpenContext> headTagOpen() {
10079                        return getRuleContexts(HeadTagOpenContext.class);
10080                }
10081                public HeadTagOpenContext headTagOpen(int i) {
10082                        return getRuleContext(HeadTagOpenContext.class,i);
10083                }
10084                public List<HtmlTagOpenContext> htmlTagOpen() {
10085                        return getRuleContexts(HtmlTagOpenContext.class);
10086                }
10087                public HtmlTagOpenContext htmlTagOpen(int i) {
10088                        return getRuleContext(HtmlTagOpenContext.class,i);
10089                }
10090                public List<OptionTagOpenContext> optionTagOpen() {
10091                        return getRuleContexts(OptionTagOpenContext.class);
10092                }
10093                public OptionTagOpenContext optionTagOpen(int i) {
10094                        return getRuleContext(OptionTagOpenContext.class,i);
10095                }
10096                public List<TheadTagOpenContext> theadTagOpen() {
10097                        return getRuleContexts(TheadTagOpenContext.class);
10098                }
10099                public TheadTagOpenContext theadTagOpen(int i) {
10100                        return getRuleContext(TheadTagOpenContext.class,i);
10101                }
10102                public List<TfootTagOpenContext> tfootTagOpen() {
10103                        return getRuleContexts(TfootTagOpenContext.class);
10104                }
10105                public TfootTagOpenContext tfootTagOpen(int i) {
10106                        return getRuleContext(TfootTagOpenContext.class,i);
10107                }
10108                public List<HtmlCommentContext> htmlComment() {
10109                        return getRuleContexts(HtmlCommentContext.class);
10110                }
10111                public HtmlCommentContext htmlComment(int i) {
10112                        return getRuleContext(HtmlCommentContext.class,i);
10113                }
10114                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10115                public TerminalNode CDATA(int i) {
10116                        return getToken(JavadocParser.CDATA, i);
10117                }
10118                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10119                public TerminalNode NEWLINE(int i) {
10120                        return getToken(JavadocParser.NEWLINE, i);
10121                }
10122                public List<TextContext> text() {
10123                        return getRuleContexts(TextContext.class);
10124                }
10125                public TextContext text(int i) {
10126                        return getRuleContext(TextContext.class,i);
10127                }
10128                public List<JavadocInlineTagContext> javadocInlineTag() {
10129                        return getRuleContexts(JavadocInlineTagContext.class);
10130                }
10131                public JavadocInlineTagContext javadocInlineTag(int i) {
10132                        return getRuleContext(JavadocInlineTagContext.class,i);
10133                }
10134                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10135                public TerminalNode LEADING_ASTERISK(int i) {
10136                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10137                }
10138                public TbodyContext(ParserRuleContext parent, int invokingState) {
10139                        super(parent, invokingState);
10140                }
10141                @Override public int getRuleIndex() { return RULE_tbody; }
10142                @Override
10143                public void enterRule(ParseTreeListener listener) {
10144                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this);
10145                }
10146                @Override
10147                public void exitRule(ParseTreeListener listener) {
10148                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this);
10149                }
10150                @Override
10151                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10152                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this);
10153                        else return visitor.visitChildren(this);
10154                }
10155        }
10156
10157        public final TbodyContext tbody() throws RecognitionException {
10158                TbodyContext _localctx = new TbodyContext(_ctx, getState());
10159                enterRule(_localctx, 88, RULE_tbody);
10160                try {
10161                        int _alt;
10162                        enterOuterAlt(_localctx, 1);
10163                        {
10164                        setState(1158);
10165                        tbodyTagOpen();
10166                        setState(1198);
10167                        _errHandler.sync(this);
10168                        _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10169                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10170                                if ( _alt==1 ) {
10171                                        {
10172                                        setState(1196);
10173                                        _errHandler.sync(this);
10174                                        switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
10175                                        case 1:
10176                                                {
10177                                                setState(1159);
10178                                                htmlTag();
10179                                                }
10180                                                break;
10181                                        case 2:
10182                                                {
10183                                                setState(1160);
10184                                                singletonTag();
10185                                                }
10186                                                break;
10187                                        case 3:
10188                                                {
10189                                                setState(1161);
10190                                                paragraph();
10191                                                }
10192                                                break;
10193                                        case 4:
10194                                                {
10195                                                setState(1162);
10196                                                li();
10197                                                }
10198                                                break;
10199                                        case 5:
10200                                                {
10201                                                setState(1163);
10202                                                tr();
10203                                                }
10204                                                break;
10205                                        case 6:
10206                                                {
10207                                                setState(1164);
10208                                                td();
10209                                                }
10210                                                break;
10211                                        case 7:
10212                                                {
10213                                                setState(1165);
10214                                                th();
10215                                                }
10216                                                break;
10217                                        case 8:
10218                                                {
10219                                                setState(1166);
10220                                                body();
10221                                                }
10222                                                break;
10223                                        case 9:
10224                                                {
10225                                                setState(1167);
10226                                                colgroup();
10227                                                }
10228                                                break;
10229                                        case 10:
10230                                                {
10231                                                setState(1168);
10232                                                dd();
10233                                                }
10234                                                break;
10235                                        case 11:
10236                                                {
10237                                                setState(1169);
10238                                                dt();
10239                                                }
10240                                                break;
10241                                        case 12:
10242                                                {
10243                                                setState(1170);
10244                                                head();
10245                                                }
10246                                                break;
10247                                        case 13:
10248                                                {
10249                                                setState(1171);
10250                                                html();
10251                                                }
10252                                                break;
10253                                        case 14:
10254                                                {
10255                                                setState(1172);
10256                                                option();
10257                                                }
10258                                                break;
10259                                        case 15:
10260                                                {
10261                                                setState(1173);
10262                                                thead();
10263                                                }
10264                                                break;
10265                                        case 16:
10266                                                {
10267                                                setState(1174);
10268                                                tfoot();
10269                                                }
10270                                                break;
10271                                        case 17:
10272                                                {
10273                                                setState(1175);
10274                                                pTagOpen();
10275                                                }
10276                                                break;
10277                                        case 18:
10278                                                {
10279                                                setState(1176);
10280                                                liTagOpen();
10281                                                }
10282                                                break;
10283                                        case 19:
10284                                                {
10285                                                setState(1177);
10286                                                trTagOpen();
10287                                                }
10288                                                break;
10289                                        case 20:
10290                                                {
10291                                                setState(1178);
10292                                                tdTagOpen();
10293                                                }
10294                                                break;
10295                                        case 21:
10296                                                {
10297                                                setState(1179);
10298                                                thTagOpen();
10299                                                }
10300                                                break;
10301                                        case 22:
10302                                                {
10303                                                setState(1180);
10304                                                bodyTagOpen();
10305                                                }
10306                                                break;
10307                                        case 23:
10308                                                {
10309                                                setState(1181);
10310                                                colgroupTagOpen();
10311                                                }
10312                                                break;
10313                                        case 24:
10314                                                {
10315                                                setState(1182);
10316                                                ddTagOpen();
10317                                                }
10318                                                break;
10319                                        case 25:
10320                                                {
10321                                                setState(1183);
10322                                                dtTagOpen();
10323                                                }
10324                                                break;
10325                                        case 26:
10326                                                {
10327                                                setState(1184);
10328                                                headTagOpen();
10329                                                }
10330                                                break;
10331                                        case 27:
10332                                                {
10333                                                setState(1185);
10334                                                htmlTagOpen();
10335                                                }
10336                                                break;
10337                                        case 28:
10338                                                {
10339                                                setState(1186);
10340                                                optionTagOpen();
10341                                                }
10342                                                break;
10343                                        case 29:
10344                                                {
10345                                                setState(1187);
10346                                                theadTagOpen();
10347                                                }
10348                                                break;
10349                                        case 30:
10350                                                {
10351                                                setState(1188);
10352                                                tfootTagOpen();
10353                                                }
10354                                                break;
10355                                        case 31:
10356                                                {
10357                                                {
10358                                                setState(1189);
10359                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10360                                                setState(1190);
10361                                                match(LEADING_ASTERISK);
10362                                                }
10363                                                }
10364                                                break;
10365                                        case 32:
10366                                                {
10367                                                setState(1191);
10368                                                htmlComment();
10369                                                }
10370                                                break;
10371                                        case 33:
10372                                                {
10373                                                setState(1192);
10374                                                match(CDATA);
10375                                                }
10376                                                break;
10377                                        case 34:
10378                                                {
10379                                                setState(1193);
10380                                                match(NEWLINE);
10381                                                }
10382                                                break;
10383                                        case 35:
10384                                                {
10385                                                setState(1194);
10386                                                text();
10387                                                }
10388                                                break;
10389                                        case 36:
10390                                                {
10391                                                setState(1195);
10392                                                javadocInlineTag();
10393                                                }
10394                                                break;
10395                                        }
10396                                        } 
10397                                }
10398                                setState(1200);
10399                                _errHandler.sync(this);
10400                                _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10401                        }
10402                        setState(1201);
10403                        tbodyTagClose();
10404                        }
10405                }
10406                catch (RecognitionException re) {
10407                        _localctx.exception = re;
10408                        _errHandler.reportError(this, re);
10409                        _errHandler.recover(this, re);
10410                }
10411                finally {
10412                        exitRule();
10413                }
10414                return _localctx;
10415        }
10416
10417        public static class TfootTagOpenContext extends ParserRuleContext {
10418                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10419                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10420                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10421                public List<AttributeContext> attribute() {
10422                        return getRuleContexts(AttributeContext.class);
10423                }
10424                public AttributeContext attribute(int i) {
10425                        return getRuleContext(AttributeContext.class,i);
10426                }
10427                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10428                public TerminalNode NEWLINE(int i) {
10429                        return getToken(JavadocParser.NEWLINE, i);
10430                }
10431                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10432                public TerminalNode LEADING_ASTERISK(int i) {
10433                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10434                }
10435                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10436                public TerminalNode WS(int i) {
10437                        return getToken(JavadocParser.WS, i);
10438                }
10439                public TfootTagOpenContext(ParserRuleContext parent, int invokingState) {
10440                        super(parent, invokingState);
10441                }
10442                @Override public int getRuleIndex() { return RULE_tfootTagOpen; }
10443                @Override
10444                public void enterRule(ParseTreeListener listener) {
10445                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this);
10446                }
10447                @Override
10448                public void exitRule(ParseTreeListener listener) {
10449                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this);
10450                }
10451                @Override
10452                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10453                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this);
10454                        else return visitor.visitChildren(this);
10455                }
10456        }
10457
10458        public final TfootTagOpenContext tfootTagOpen() throws RecognitionException {
10459                TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState());
10460                enterRule(_localctx, 90, RULE_tfootTagOpen);
10461                int _la;
10462                try {
10463                        enterOuterAlt(_localctx, 1);
10464                        {
10465                        setState(1203);
10466                        match(OPEN);
10467                        setState(1204);
10468                        match(TFOOT_HTML_TAG_NAME);
10469                        setState(1211);
10470                        _errHandler.sync(this);
10471                        _la = _input.LA(1);
10472                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10473                                {
10474                                setState(1209);
10475                                _errHandler.sync(this);
10476                                switch (_input.LA(1)) {
10477                                case HTML_TAG_NAME:
10478                                        {
10479                                        setState(1205);
10480                                        attribute();
10481                                        }
10482                                        break;
10483                                case NEWLINE:
10484                                        {
10485                                        setState(1206);
10486                                        match(NEWLINE);
10487                                        }
10488                                        break;
10489                                case LEADING_ASTERISK:
10490                                        {
10491                                        setState(1207);
10492                                        match(LEADING_ASTERISK);
10493                                        }
10494                                        break;
10495                                case WS:
10496                                        {
10497                                        setState(1208);
10498                                        match(WS);
10499                                        }
10500                                        break;
10501                                default:
10502                                        throw new NoViableAltException(this);
10503                                }
10504                                }
10505                                setState(1213);
10506                                _errHandler.sync(this);
10507                                _la = _input.LA(1);
10508                        }
10509                        setState(1214);
10510                        match(CLOSE);
10511                        }
10512                }
10513                catch (RecognitionException re) {
10514                        _localctx.exception = re;
10515                        _errHandler.reportError(this, re);
10516                        _errHandler.recover(this, re);
10517                }
10518                finally {
10519                        exitRule();
10520                }
10521                return _localctx;
10522        }
10523
10524        public static class TfootTagCloseContext extends ParserRuleContext {
10525                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10526                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10527                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10528                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10529                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10530                public TerminalNode NEWLINE(int i) {
10531                        return getToken(JavadocParser.NEWLINE, i);
10532                }
10533                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10534                public TerminalNode LEADING_ASTERISK(int i) {
10535                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10536                }
10537                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10538                public TerminalNode WS(int i) {
10539                        return getToken(JavadocParser.WS, i);
10540                }
10541                public TfootTagCloseContext(ParserRuleContext parent, int invokingState) {
10542                        super(parent, invokingState);
10543                }
10544                @Override public int getRuleIndex() { return RULE_tfootTagClose; }
10545                @Override
10546                public void enterRule(ParseTreeListener listener) {
10547                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this);
10548                }
10549                @Override
10550                public void exitRule(ParseTreeListener listener) {
10551                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this);
10552                }
10553                @Override
10554                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10555                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this);
10556                        else return visitor.visitChildren(this);
10557                }
10558        }
10559
10560        public final TfootTagCloseContext tfootTagClose() throws RecognitionException {
10561                TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState());
10562                enterRule(_localctx, 92, RULE_tfootTagClose);
10563                int _la;
10564                try {
10565                        enterOuterAlt(_localctx, 1);
10566                        {
10567                        setState(1216);
10568                        match(OPEN);
10569                        setState(1217);
10570                        match(SLASH);
10571                        setState(1218);
10572                        match(TFOOT_HTML_TAG_NAME);
10573                        setState(1222);
10574                        _errHandler.sync(this);
10575                        _la = _input.LA(1);
10576                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10577                                {
10578                                {
10579                                setState(1219);
10580                                _la = _input.LA(1);
10581                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10582                                _errHandler.recoverInline(this);
10583                                }
10584                                else {
10585                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
10586                                        _errHandler.reportMatch(this);
10587                                        consume();
10588                                }
10589                                }
10590                                }
10591                                setState(1224);
10592                                _errHandler.sync(this);
10593                                _la = _input.LA(1);
10594                        }
10595                        setState(1225);
10596                        match(CLOSE);
10597                        }
10598                }
10599                catch (RecognitionException re) {
10600                        _localctx.exception = re;
10601                        _errHandler.reportError(this, re);
10602                        _errHandler.recover(this, re);
10603                }
10604                finally {
10605                        exitRule();
10606                }
10607                return _localctx;
10608        }
10609
10610        public static class TfootContext extends ParserRuleContext {
10611                public TfootTagOpenContext tfootTagOpen() {
10612                        return getRuleContext(TfootTagOpenContext.class,0);
10613                }
10614                public TfootTagCloseContext tfootTagClose() {
10615                        return getRuleContext(TfootTagCloseContext.class,0);
10616                }
10617                public List<HtmlTagContext> htmlTag() {
10618                        return getRuleContexts(HtmlTagContext.class);
10619                }
10620                public HtmlTagContext htmlTag(int i) {
10621                        return getRuleContext(HtmlTagContext.class,i);
10622                }
10623                public List<SingletonTagContext> singletonTag() {
10624                        return getRuleContexts(SingletonTagContext.class);
10625                }
10626                public SingletonTagContext singletonTag(int i) {
10627                        return getRuleContext(SingletonTagContext.class,i);
10628                }
10629                public List<ParagraphContext> paragraph() {
10630                        return getRuleContexts(ParagraphContext.class);
10631                }
10632                public ParagraphContext paragraph(int i) {
10633                        return getRuleContext(ParagraphContext.class,i);
10634                }
10635                public List<LiContext> li() {
10636                        return getRuleContexts(LiContext.class);
10637                }
10638                public LiContext li(int i) {
10639                        return getRuleContext(LiContext.class,i);
10640                }
10641                public List<TrContext> tr() {
10642                        return getRuleContexts(TrContext.class);
10643                }
10644                public TrContext tr(int i) {
10645                        return getRuleContext(TrContext.class,i);
10646                }
10647                public List<TdContext> td() {
10648                        return getRuleContexts(TdContext.class);
10649                }
10650                public TdContext td(int i) {
10651                        return getRuleContext(TdContext.class,i);
10652                }
10653                public List<ThContext> th() {
10654                        return getRuleContexts(ThContext.class);
10655                }
10656                public ThContext th(int i) {
10657                        return getRuleContext(ThContext.class,i);
10658                }
10659                public List<BodyContext> body() {
10660                        return getRuleContexts(BodyContext.class);
10661                }
10662                public BodyContext body(int i) {
10663                        return getRuleContext(BodyContext.class,i);
10664                }
10665                public List<ColgroupContext> colgroup() {
10666                        return getRuleContexts(ColgroupContext.class);
10667                }
10668                public ColgroupContext colgroup(int i) {
10669                        return getRuleContext(ColgroupContext.class,i);
10670                }
10671                public List<DdContext> dd() {
10672                        return getRuleContexts(DdContext.class);
10673                }
10674                public DdContext dd(int i) {
10675                        return getRuleContext(DdContext.class,i);
10676                }
10677                public List<DtContext> dt() {
10678                        return getRuleContexts(DtContext.class);
10679                }
10680                public DtContext dt(int i) {
10681                        return getRuleContext(DtContext.class,i);
10682                }
10683                public List<HeadContext> head() {
10684                        return getRuleContexts(HeadContext.class);
10685                }
10686                public HeadContext head(int i) {
10687                        return getRuleContext(HeadContext.class,i);
10688                }
10689                public List<HtmlContext> html() {
10690                        return getRuleContexts(HtmlContext.class);
10691                }
10692                public HtmlContext html(int i) {
10693                        return getRuleContext(HtmlContext.class,i);
10694                }
10695                public List<OptionContext> option() {
10696                        return getRuleContexts(OptionContext.class);
10697                }
10698                public OptionContext option(int i) {
10699                        return getRuleContext(OptionContext.class,i);
10700                }
10701                public List<TbodyContext> tbody() {
10702                        return getRuleContexts(TbodyContext.class);
10703                }
10704                public TbodyContext tbody(int i) {
10705                        return getRuleContext(TbodyContext.class,i);
10706                }
10707                public List<TheadContext> thead() {
10708                        return getRuleContexts(TheadContext.class);
10709                }
10710                public TheadContext thead(int i) {
10711                        return getRuleContext(TheadContext.class,i);
10712                }
10713                public List<PTagOpenContext> pTagOpen() {
10714                        return getRuleContexts(PTagOpenContext.class);
10715                }
10716                public PTagOpenContext pTagOpen(int i) {
10717                        return getRuleContext(PTagOpenContext.class,i);
10718                }
10719                public List<LiTagOpenContext> liTagOpen() {
10720                        return getRuleContexts(LiTagOpenContext.class);
10721                }
10722                public LiTagOpenContext liTagOpen(int i) {
10723                        return getRuleContext(LiTagOpenContext.class,i);
10724                }
10725                public List<TrTagOpenContext> trTagOpen() {
10726                        return getRuleContexts(TrTagOpenContext.class);
10727                }
10728                public TrTagOpenContext trTagOpen(int i) {
10729                        return getRuleContext(TrTagOpenContext.class,i);
10730                }
10731                public List<TdTagOpenContext> tdTagOpen() {
10732                        return getRuleContexts(TdTagOpenContext.class);
10733                }
10734                public TdTagOpenContext tdTagOpen(int i) {
10735                        return getRuleContext(TdTagOpenContext.class,i);
10736                }
10737                public List<ThTagOpenContext> thTagOpen() {
10738                        return getRuleContexts(ThTagOpenContext.class);
10739                }
10740                public ThTagOpenContext thTagOpen(int i) {
10741                        return getRuleContext(ThTagOpenContext.class,i);
10742                }
10743                public List<BodyTagOpenContext> bodyTagOpen() {
10744                        return getRuleContexts(BodyTagOpenContext.class);
10745                }
10746                public BodyTagOpenContext bodyTagOpen(int i) {
10747                        return getRuleContext(BodyTagOpenContext.class,i);
10748                }
10749                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10750                        return getRuleContexts(ColgroupTagOpenContext.class);
10751                }
10752                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10753                        return getRuleContext(ColgroupTagOpenContext.class,i);
10754                }
10755                public List<DdTagOpenContext> ddTagOpen() {
10756                        return getRuleContexts(DdTagOpenContext.class);
10757                }
10758                public DdTagOpenContext ddTagOpen(int i) {
10759                        return getRuleContext(DdTagOpenContext.class,i);
10760                }
10761                public List<DtTagOpenContext> dtTagOpen() {
10762                        return getRuleContexts(DtTagOpenContext.class);
10763                }
10764                public DtTagOpenContext dtTagOpen(int i) {
10765                        return getRuleContext(DtTagOpenContext.class,i);
10766                }
10767                public List<HeadTagOpenContext> headTagOpen() {
10768                        return getRuleContexts(HeadTagOpenContext.class);
10769                }
10770                public HeadTagOpenContext headTagOpen(int i) {
10771                        return getRuleContext(HeadTagOpenContext.class,i);
10772                }
10773                public List<HtmlTagOpenContext> htmlTagOpen() {
10774                        return getRuleContexts(HtmlTagOpenContext.class);
10775                }
10776                public HtmlTagOpenContext htmlTagOpen(int i) {
10777                        return getRuleContext(HtmlTagOpenContext.class,i);
10778                }
10779                public List<OptionTagOpenContext> optionTagOpen() {
10780                        return getRuleContexts(OptionTagOpenContext.class);
10781                }
10782                public OptionTagOpenContext optionTagOpen(int i) {
10783                        return getRuleContext(OptionTagOpenContext.class,i);
10784                }
10785                public List<TbodyTagOpenContext> tbodyTagOpen() {
10786                        return getRuleContexts(TbodyTagOpenContext.class);
10787                }
10788                public TbodyTagOpenContext tbodyTagOpen(int i) {
10789                        return getRuleContext(TbodyTagOpenContext.class,i);
10790                }
10791                public List<TheadTagOpenContext> theadTagOpen() {
10792                        return getRuleContexts(TheadTagOpenContext.class);
10793                }
10794                public TheadTagOpenContext theadTagOpen(int i) {
10795                        return getRuleContext(TheadTagOpenContext.class,i);
10796                }
10797                public List<HtmlCommentContext> htmlComment() {
10798                        return getRuleContexts(HtmlCommentContext.class);
10799                }
10800                public HtmlCommentContext htmlComment(int i) {
10801                        return getRuleContext(HtmlCommentContext.class,i);
10802                }
10803                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10804                public TerminalNode CDATA(int i) {
10805                        return getToken(JavadocParser.CDATA, i);
10806                }
10807                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10808                public TerminalNode NEWLINE(int i) {
10809                        return getToken(JavadocParser.NEWLINE, i);
10810                }
10811                public List<TextContext> text() {
10812                        return getRuleContexts(TextContext.class);
10813                }
10814                public TextContext text(int i) {
10815                        return getRuleContext(TextContext.class,i);
10816                }
10817                public List<JavadocInlineTagContext> javadocInlineTag() {
10818                        return getRuleContexts(JavadocInlineTagContext.class);
10819                }
10820                public JavadocInlineTagContext javadocInlineTag(int i) {
10821                        return getRuleContext(JavadocInlineTagContext.class,i);
10822                }
10823                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10824                public TerminalNode LEADING_ASTERISK(int i) {
10825                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10826                }
10827                public TfootContext(ParserRuleContext parent, int invokingState) {
10828                        super(parent, invokingState);
10829                }
10830                @Override public int getRuleIndex() { return RULE_tfoot; }
10831                @Override
10832                public void enterRule(ParseTreeListener listener) {
10833                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this);
10834                }
10835                @Override
10836                public void exitRule(ParseTreeListener listener) {
10837                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this);
10838                }
10839                @Override
10840                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10841                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this);
10842                        else return visitor.visitChildren(this);
10843                }
10844        }
10845
10846        public final TfootContext tfoot() throws RecognitionException {
10847                TfootContext _localctx = new TfootContext(_ctx, getState());
10848                enterRule(_localctx, 94, RULE_tfoot);
10849                try {
10850                        int _alt;
10851                        enterOuterAlt(_localctx, 1);
10852                        {
10853                        setState(1227);
10854                        tfootTagOpen();
10855                        setState(1267);
10856                        _errHandler.sync(this);
10857                        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10858                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10859                                if ( _alt==1 ) {
10860                                        {
10861                                        setState(1265);
10862                                        _errHandler.sync(this);
10863                                        switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
10864                                        case 1:
10865                                                {
10866                                                setState(1228);
10867                                                htmlTag();
10868                                                }
10869                                                break;
10870                                        case 2:
10871                                                {
10872                                                setState(1229);
10873                                                singletonTag();
10874                                                }
10875                                                break;
10876                                        case 3:
10877                                                {
10878                                                setState(1230);
10879                                                paragraph();
10880                                                }
10881                                                break;
10882                                        case 4:
10883                                                {
10884                                                setState(1231);
10885                                                li();
10886                                                }
10887                                                break;
10888                                        case 5:
10889                                                {
10890                                                setState(1232);
10891                                                tr();
10892                                                }
10893                                                break;
10894                                        case 6:
10895                                                {
10896                                                setState(1233);
10897                                                td();
10898                                                }
10899                                                break;
10900                                        case 7:
10901                                                {
10902                                                setState(1234);
10903                                                th();
10904                                                }
10905                                                break;
10906                                        case 8:
10907                                                {
10908                                                setState(1235);
10909                                                body();
10910                                                }
10911                                                break;
10912                                        case 9:
10913                                                {
10914                                                setState(1236);
10915                                                colgroup();
10916                                                }
10917                                                break;
10918                                        case 10:
10919                                                {
10920                                                setState(1237);
10921                                                dd();
10922                                                }
10923                                                break;
10924                                        case 11:
10925                                                {
10926                                                setState(1238);
10927                                                dt();
10928                                                }
10929                                                break;
10930                                        case 12:
10931                                                {
10932                                                setState(1239);
10933                                                head();
10934                                                }
10935                                                break;
10936                                        case 13:
10937                                                {
10938                                                setState(1240);
10939                                                html();
10940                                                }
10941                                                break;
10942                                        case 14:
10943                                                {
10944                                                setState(1241);
10945                                                option();
10946                                                }
10947                                                break;
10948                                        case 15:
10949                                                {
10950                                                setState(1242);
10951                                                tbody();
10952                                                }
10953                                                break;
10954                                        case 16:
10955                                                {
10956                                                setState(1243);
10957                                                thead();
10958                                                }
10959                                                break;
10960                                        case 17:
10961                                                {
10962                                                setState(1244);
10963                                                pTagOpen();
10964                                                }
10965                                                break;
10966                                        case 18:
10967                                                {
10968                                                setState(1245);
10969                                                liTagOpen();
10970                                                }
10971                                                break;
10972                                        case 19:
10973                                                {
10974                                                setState(1246);
10975                                                trTagOpen();
10976                                                }
10977                                                break;
10978                                        case 20:
10979                                                {
10980                                                setState(1247);
10981                                                tdTagOpen();
10982                                                }
10983                                                break;
10984                                        case 21:
10985                                                {
10986                                                setState(1248);
10987                                                thTagOpen();
10988                                                }
10989                                                break;
10990                                        case 22:
10991                                                {
10992                                                setState(1249);
10993                                                bodyTagOpen();
10994                                                }
10995                                                break;
10996                                        case 23:
10997                                                {
10998                                                setState(1250);
10999                                                colgroupTagOpen();
11000                                                }
11001                                                break;
11002                                        case 24:
11003                                                {
11004                                                setState(1251);
11005                                                ddTagOpen();
11006                                                }
11007                                                break;
11008                                        case 25:
11009                                                {
11010                                                setState(1252);
11011                                                dtTagOpen();
11012                                                }
11013                                                break;
11014                                        case 26:
11015                                                {
11016                                                setState(1253);
11017                                                headTagOpen();
11018                                                }
11019                                                break;
11020                                        case 27:
11021                                                {
11022                                                setState(1254);
11023                                                htmlTagOpen();
11024                                                }
11025                                                break;
11026                                        case 28:
11027                                                {
11028                                                setState(1255);
11029                                                optionTagOpen();
11030                                                }
11031                                                break;
11032                                        case 29:
11033                                                {
11034                                                setState(1256);
11035                                                tbodyTagOpen();
11036                                                }
11037                                                break;
11038                                        case 30:
11039                                                {
11040                                                setState(1257);
11041                                                theadTagOpen();
11042                                                }
11043                                                break;
11044                                        case 31:
11045                                                {
11046                                                {
11047                                                setState(1258);
11048                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11049                                                setState(1259);
11050                                                match(LEADING_ASTERISK);
11051                                                }
11052                                                }
11053                                                break;
11054                                        case 32:
11055                                                {
11056                                                setState(1260);
11057                                                htmlComment();
11058                                                }
11059                                                break;
11060                                        case 33:
11061                                                {
11062                                                setState(1261);
11063                                                match(CDATA);
11064                                                }
11065                                                break;
11066                                        case 34:
11067                                                {
11068                                                setState(1262);
11069                                                match(NEWLINE);
11070                                                }
11071                                                break;
11072                                        case 35:
11073                                                {
11074                                                setState(1263);
11075                                                text();
11076                                                }
11077                                                break;
11078                                        case 36:
11079                                                {
11080                                                setState(1264);
11081                                                javadocInlineTag();
11082                                                }
11083                                                break;
11084                                        }
11085                                        } 
11086                                }
11087                                setState(1269);
11088                                _errHandler.sync(this);
11089                                _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
11090                        }
11091                        setState(1270);
11092                        tfootTagClose();
11093                        }
11094                }
11095                catch (RecognitionException re) {
11096                        _localctx.exception = re;
11097                        _errHandler.reportError(this, re);
11098                        _errHandler.recover(this, re);
11099                }
11100                finally {
11101                        exitRule();
11102                }
11103                return _localctx;
11104        }
11105
11106        public static class TheadTagOpenContext extends ParserRuleContext {
11107                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11108                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11109                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11110                public List<AttributeContext> attribute() {
11111                        return getRuleContexts(AttributeContext.class);
11112                }
11113                public AttributeContext attribute(int i) {
11114                        return getRuleContext(AttributeContext.class,i);
11115                }
11116                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11117                public TerminalNode NEWLINE(int i) {
11118                        return getToken(JavadocParser.NEWLINE, i);
11119                }
11120                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11121                public TerminalNode LEADING_ASTERISK(int i) {
11122                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11123                }
11124                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11125                public TerminalNode WS(int i) {
11126                        return getToken(JavadocParser.WS, i);
11127                }
11128                public TheadTagOpenContext(ParserRuleContext parent, int invokingState) {
11129                        super(parent, invokingState);
11130                }
11131                @Override public int getRuleIndex() { return RULE_theadTagOpen; }
11132                @Override
11133                public void enterRule(ParseTreeListener listener) {
11134                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this);
11135                }
11136                @Override
11137                public void exitRule(ParseTreeListener listener) {
11138                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this);
11139                }
11140                @Override
11141                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11142                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this);
11143                        else return visitor.visitChildren(this);
11144                }
11145        }
11146
11147        public final TheadTagOpenContext theadTagOpen() throws RecognitionException {
11148                TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState());
11149                enterRule(_localctx, 96, RULE_theadTagOpen);
11150                int _la;
11151                try {
11152                        enterOuterAlt(_localctx, 1);
11153                        {
11154                        setState(1272);
11155                        match(OPEN);
11156                        setState(1273);
11157                        match(THEAD_HTML_TAG_NAME);
11158                        setState(1280);
11159                        _errHandler.sync(this);
11160                        _la = _input.LA(1);
11161                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11162                                {
11163                                setState(1278);
11164                                _errHandler.sync(this);
11165                                switch (_input.LA(1)) {
11166                                case HTML_TAG_NAME:
11167                                        {
11168                                        setState(1274);
11169                                        attribute();
11170                                        }
11171                                        break;
11172                                case NEWLINE:
11173                                        {
11174                                        setState(1275);
11175                                        match(NEWLINE);
11176                                        }
11177                                        break;
11178                                case LEADING_ASTERISK:
11179                                        {
11180                                        setState(1276);
11181                                        match(LEADING_ASTERISK);
11182                                        }
11183                                        break;
11184                                case WS:
11185                                        {
11186                                        setState(1277);
11187                                        match(WS);
11188                                        }
11189                                        break;
11190                                default:
11191                                        throw new NoViableAltException(this);
11192                                }
11193                                }
11194                                setState(1282);
11195                                _errHandler.sync(this);
11196                                _la = _input.LA(1);
11197                        }
11198                        setState(1283);
11199                        match(CLOSE);
11200                        }
11201                }
11202                catch (RecognitionException re) {
11203                        _localctx.exception = re;
11204                        _errHandler.reportError(this, re);
11205                        _errHandler.recover(this, re);
11206                }
11207                finally {
11208                        exitRule();
11209                }
11210                return _localctx;
11211        }
11212
11213        public static class TheadTagCloseContext extends ParserRuleContext {
11214                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11215                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
11216                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11217                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11218                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11219                public TerminalNode NEWLINE(int i) {
11220                        return getToken(JavadocParser.NEWLINE, i);
11221                }
11222                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11223                public TerminalNode LEADING_ASTERISK(int i) {
11224                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11225                }
11226                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11227                public TerminalNode WS(int i) {
11228                        return getToken(JavadocParser.WS, i);
11229                }
11230                public TheadTagCloseContext(ParserRuleContext parent, int invokingState) {
11231                        super(parent, invokingState);
11232                }
11233                @Override public int getRuleIndex() { return RULE_theadTagClose; }
11234                @Override
11235                public void enterRule(ParseTreeListener listener) {
11236                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this);
11237                }
11238                @Override
11239                public void exitRule(ParseTreeListener listener) {
11240                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this);
11241                }
11242                @Override
11243                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11244                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this);
11245                        else return visitor.visitChildren(this);
11246                }
11247        }
11248
11249        public final TheadTagCloseContext theadTagClose() throws RecognitionException {
11250                TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState());
11251                enterRule(_localctx, 98, RULE_theadTagClose);
11252                int _la;
11253                try {
11254                        enterOuterAlt(_localctx, 1);
11255                        {
11256                        setState(1285);
11257                        match(OPEN);
11258                        setState(1286);
11259                        match(SLASH);
11260                        setState(1287);
11261                        match(THEAD_HTML_TAG_NAME);
11262                        setState(1291);
11263                        _errHandler.sync(this);
11264                        _la = _input.LA(1);
11265                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
11266                                {
11267                                {
11268                                setState(1288);
11269                                _la = _input.LA(1);
11270                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
11271                                _errHandler.recoverInline(this);
11272                                }
11273                                else {
11274                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
11275                                        _errHandler.reportMatch(this);
11276                                        consume();
11277                                }
11278                                }
11279                                }
11280                                setState(1293);
11281                                _errHandler.sync(this);
11282                                _la = _input.LA(1);
11283                        }
11284                        setState(1294);
11285                        match(CLOSE);
11286                        }
11287                }
11288                catch (RecognitionException re) {
11289                        _localctx.exception = re;
11290                        _errHandler.reportError(this, re);
11291                        _errHandler.recover(this, re);
11292                }
11293                finally {
11294                        exitRule();
11295                }
11296                return _localctx;
11297        }
11298
11299        public static class TheadContext extends ParserRuleContext {
11300                public TheadTagOpenContext theadTagOpen() {
11301                        return getRuleContext(TheadTagOpenContext.class,0);
11302                }
11303                public TheadTagCloseContext theadTagClose() {
11304                        return getRuleContext(TheadTagCloseContext.class,0);
11305                }
11306                public List<HtmlTagContext> htmlTag() {
11307                        return getRuleContexts(HtmlTagContext.class);
11308                }
11309                public HtmlTagContext htmlTag(int i) {
11310                        return getRuleContext(HtmlTagContext.class,i);
11311                }
11312                public List<SingletonTagContext> singletonTag() {
11313                        return getRuleContexts(SingletonTagContext.class);
11314                }
11315                public SingletonTagContext singletonTag(int i) {
11316                        return getRuleContext(SingletonTagContext.class,i);
11317                }
11318                public List<ParagraphContext> paragraph() {
11319                        return getRuleContexts(ParagraphContext.class);
11320                }
11321                public ParagraphContext paragraph(int i) {
11322                        return getRuleContext(ParagraphContext.class,i);
11323                }
11324                public List<LiContext> li() {
11325                        return getRuleContexts(LiContext.class);
11326                }
11327                public LiContext li(int i) {
11328                        return getRuleContext(LiContext.class,i);
11329                }
11330                public List<TrContext> tr() {
11331                        return getRuleContexts(TrContext.class);
11332                }
11333                public TrContext tr(int i) {
11334                        return getRuleContext(TrContext.class,i);
11335                }
11336                public List<TdContext> td() {
11337                        return getRuleContexts(TdContext.class);
11338                }
11339                public TdContext td(int i) {
11340                        return getRuleContext(TdContext.class,i);
11341                }
11342                public List<ThContext> th() {
11343                        return getRuleContexts(ThContext.class);
11344                }
11345                public ThContext th(int i) {
11346                        return getRuleContext(ThContext.class,i);
11347                }
11348                public List<BodyContext> body() {
11349                        return getRuleContexts(BodyContext.class);
11350                }
11351                public BodyContext body(int i) {
11352                        return getRuleContext(BodyContext.class,i);
11353                }
11354                public List<ColgroupContext> colgroup() {
11355                        return getRuleContexts(ColgroupContext.class);
11356                }
11357                public ColgroupContext colgroup(int i) {
11358                        return getRuleContext(ColgroupContext.class,i);
11359                }
11360                public List<DdContext> dd() {
11361                        return getRuleContexts(DdContext.class);
11362                }
11363                public DdContext dd(int i) {
11364                        return getRuleContext(DdContext.class,i);
11365                }
11366                public List<DtContext> dt() {
11367                        return getRuleContexts(DtContext.class);
11368                }
11369                public DtContext dt(int i) {
11370                        return getRuleContext(DtContext.class,i);
11371                }
11372                public List<HeadContext> head() {
11373                        return getRuleContexts(HeadContext.class);
11374                }
11375                public HeadContext head(int i) {
11376                        return getRuleContext(HeadContext.class,i);
11377                }
11378                public List<HtmlContext> html() {
11379                        return getRuleContexts(HtmlContext.class);
11380                }
11381                public HtmlContext html(int i) {
11382                        return getRuleContext(HtmlContext.class,i);
11383                }
11384                public List<OptionContext> option() {
11385                        return getRuleContexts(OptionContext.class);
11386                }
11387                public OptionContext option(int i) {
11388                        return getRuleContext(OptionContext.class,i);
11389                }
11390                public List<TbodyContext> tbody() {
11391                        return getRuleContexts(TbodyContext.class);
11392                }
11393                public TbodyContext tbody(int i) {
11394                        return getRuleContext(TbodyContext.class,i);
11395                }
11396                public List<TfootContext> tfoot() {
11397                        return getRuleContexts(TfootContext.class);
11398                }
11399                public TfootContext tfoot(int i) {
11400                        return getRuleContext(TfootContext.class,i);
11401                }
11402                public List<PTagOpenContext> pTagOpen() {
11403                        return getRuleContexts(PTagOpenContext.class);
11404                }
11405                public PTagOpenContext pTagOpen(int i) {
11406                        return getRuleContext(PTagOpenContext.class,i);
11407                }
11408                public List<LiTagOpenContext> liTagOpen() {
11409                        return getRuleContexts(LiTagOpenContext.class);
11410                }
11411                public LiTagOpenContext liTagOpen(int i) {
11412                        return getRuleContext(LiTagOpenContext.class,i);
11413                }
11414                public List<TrTagOpenContext> trTagOpen() {
11415                        return getRuleContexts(TrTagOpenContext.class);
11416                }
11417                public TrTagOpenContext trTagOpen(int i) {
11418                        return getRuleContext(TrTagOpenContext.class,i);
11419                }
11420                public List<TdTagOpenContext> tdTagOpen() {
11421                        return getRuleContexts(TdTagOpenContext.class);
11422                }
11423                public TdTagOpenContext tdTagOpen(int i) {
11424                        return getRuleContext(TdTagOpenContext.class,i);
11425                }
11426                public List<ThTagOpenContext> thTagOpen() {
11427                        return getRuleContexts(ThTagOpenContext.class);
11428                }
11429                public ThTagOpenContext thTagOpen(int i) {
11430                        return getRuleContext(ThTagOpenContext.class,i);
11431                }
11432                public List<BodyTagOpenContext> bodyTagOpen() {
11433                        return getRuleContexts(BodyTagOpenContext.class);
11434                }
11435                public BodyTagOpenContext bodyTagOpen(int i) {
11436                        return getRuleContext(BodyTagOpenContext.class,i);
11437                }
11438                public List<ColgroupTagOpenContext> colgroupTagOpen() {
11439                        return getRuleContexts(ColgroupTagOpenContext.class);
11440                }
11441                public ColgroupTagOpenContext colgroupTagOpen(int i) {
11442                        return getRuleContext(ColgroupTagOpenContext.class,i);
11443                }
11444                public List<DdTagOpenContext> ddTagOpen() {
11445                        return getRuleContexts(DdTagOpenContext.class);
11446                }
11447                public DdTagOpenContext ddTagOpen(int i) {
11448                        return getRuleContext(DdTagOpenContext.class,i);
11449                }
11450                public List<DtTagOpenContext> dtTagOpen() {
11451                        return getRuleContexts(DtTagOpenContext.class);
11452                }
11453                public DtTagOpenContext dtTagOpen(int i) {
11454                        return getRuleContext(DtTagOpenContext.class,i);
11455                }
11456                public List<HeadTagOpenContext> headTagOpen() {
11457                        return getRuleContexts(HeadTagOpenContext.class);
11458                }
11459                public HeadTagOpenContext headTagOpen(int i) {
11460                        return getRuleContext(HeadTagOpenContext.class,i);
11461                }
11462                public List<HtmlTagOpenContext> htmlTagOpen() {
11463                        return getRuleContexts(HtmlTagOpenContext.class);
11464                }
11465                public HtmlTagOpenContext htmlTagOpen(int i) {
11466                        return getRuleContext(HtmlTagOpenContext.class,i);
11467                }
11468                public List<OptionTagOpenContext> optionTagOpen() {
11469                        return getRuleContexts(OptionTagOpenContext.class);
11470                }
11471                public OptionTagOpenContext optionTagOpen(int i) {
11472                        return getRuleContext(OptionTagOpenContext.class,i);
11473                }
11474                public List<TbodyTagOpenContext> tbodyTagOpen() {
11475                        return getRuleContexts(TbodyTagOpenContext.class);
11476                }
11477                public TbodyTagOpenContext tbodyTagOpen(int i) {
11478                        return getRuleContext(TbodyTagOpenContext.class,i);
11479                }
11480                public List<TfootTagOpenContext> tfootTagOpen() {
11481                        return getRuleContexts(TfootTagOpenContext.class);
11482                }
11483                public TfootTagOpenContext tfootTagOpen(int i) {
11484                        return getRuleContext(TfootTagOpenContext.class,i);
11485                }
11486                public List<HtmlCommentContext> htmlComment() {
11487                        return getRuleContexts(HtmlCommentContext.class);
11488                }
11489                public HtmlCommentContext htmlComment(int i) {
11490                        return getRuleContext(HtmlCommentContext.class,i);
11491                }
11492                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
11493                public TerminalNode CDATA(int i) {
11494                        return getToken(JavadocParser.CDATA, i);
11495                }
11496                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11497                public TerminalNode NEWLINE(int i) {
11498                        return getToken(JavadocParser.NEWLINE, i);
11499                }
11500                public List<TextContext> text() {
11501                        return getRuleContexts(TextContext.class);
11502                }
11503                public TextContext text(int i) {
11504                        return getRuleContext(TextContext.class,i);
11505                }
11506                public List<JavadocInlineTagContext> javadocInlineTag() {
11507                        return getRuleContexts(JavadocInlineTagContext.class);
11508                }
11509                public JavadocInlineTagContext javadocInlineTag(int i) {
11510                        return getRuleContext(JavadocInlineTagContext.class,i);
11511                }
11512                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11513                public TerminalNode LEADING_ASTERISK(int i) {
11514                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11515                }
11516                public TheadContext(ParserRuleContext parent, int invokingState) {
11517                        super(parent, invokingState);
11518                }
11519                @Override public int getRuleIndex() { return RULE_thead; }
11520                @Override
11521                public void enterRule(ParseTreeListener listener) {
11522                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this);
11523                }
11524                @Override
11525                public void exitRule(ParseTreeListener listener) {
11526                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this);
11527                }
11528                @Override
11529                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11530                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this);
11531                        else return visitor.visitChildren(this);
11532                }
11533        }
11534
11535        public final TheadContext thead() throws RecognitionException {
11536                TheadContext _localctx = new TheadContext(_ctx, getState());
11537                enterRule(_localctx, 100, RULE_thead);
11538                try {
11539                        int _alt;
11540                        enterOuterAlt(_localctx, 1);
11541                        {
11542                        setState(1296);
11543                        theadTagOpen();
11544                        setState(1336);
11545                        _errHandler.sync(this);
11546                        _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11547                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11548                                if ( _alt==1 ) {
11549                                        {
11550                                        setState(1334);
11551                                        _errHandler.sync(this);
11552                                        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
11553                                        case 1:
11554                                                {
11555                                                setState(1297);
11556                                                htmlTag();
11557                                                }
11558                                                break;
11559                                        case 2:
11560                                                {
11561                                                setState(1298);
11562                                                singletonTag();
11563                                                }
11564                                                break;
11565                                        case 3:
11566                                                {
11567                                                setState(1299);
11568                                                paragraph();
11569                                                }
11570                                                break;
11571                                        case 4:
11572                                                {
11573                                                setState(1300);
11574                                                li();
11575                                                }
11576                                                break;
11577                                        case 5:
11578                                                {
11579                                                setState(1301);
11580                                                tr();
11581                                                }
11582                                                break;
11583                                        case 6:
11584                                                {
11585                                                setState(1302);
11586                                                td();
11587                                                }
11588                                                break;
11589                                        case 7:
11590                                                {
11591                                                setState(1303);
11592                                                th();
11593                                                }
11594                                                break;
11595                                        case 8:
11596                                                {
11597                                                setState(1304);
11598                                                body();
11599                                                }
11600                                                break;
11601                                        case 9:
11602                                                {
11603                                                setState(1305);
11604                                                colgroup();
11605                                                }
11606                                                break;
11607                                        case 10:
11608                                                {
11609                                                setState(1306);
11610                                                dd();
11611                                                }
11612                                                break;
11613                                        case 11:
11614                                                {
11615                                                setState(1307);
11616                                                dt();
11617                                                }
11618                                                break;
11619                                        case 12:
11620                                                {
11621                                                setState(1308);
11622                                                head();
11623                                                }
11624                                                break;
11625                                        case 13:
11626                                                {
11627                                                setState(1309);
11628                                                html();
11629                                                }
11630                                                break;
11631                                        case 14:
11632                                                {
11633                                                setState(1310);
11634                                                option();
11635                                                }
11636                                                break;
11637                                        case 15:
11638                                                {
11639                                                setState(1311);
11640                                                tbody();
11641                                                }
11642                                                break;
11643                                        case 16:
11644                                                {
11645                                                setState(1312);
11646                                                tfoot();
11647                                                }
11648                                                break;
11649                                        case 17:
11650                                                {
11651                                                setState(1313);
11652                                                pTagOpen();
11653                                                }
11654                                                break;
11655                                        case 18:
11656                                                {
11657                                                setState(1314);
11658                                                liTagOpen();
11659                                                }
11660                                                break;
11661                                        case 19:
11662                                                {
11663                                                setState(1315);
11664                                                trTagOpen();
11665                                                }
11666                                                break;
11667                                        case 20:
11668                                                {
11669                                                setState(1316);
11670                                                tdTagOpen();
11671                                                }
11672                                                break;
11673                                        case 21:
11674                                                {
11675                                                setState(1317);
11676                                                thTagOpen();
11677                                                }
11678                                                break;
11679                                        case 22:
11680                                                {
11681                                                setState(1318);
11682                                                bodyTagOpen();
11683                                                }
11684                                                break;
11685                                        case 23:
11686                                                {
11687                                                setState(1319);
11688                                                colgroupTagOpen();
11689                                                }
11690                                                break;
11691                                        case 24:
11692                                                {
11693                                                setState(1320);
11694                                                ddTagOpen();
11695                                                }
11696                                                break;
11697                                        case 25:
11698                                                {
11699                                                setState(1321);
11700                                                dtTagOpen();
11701                                                }
11702                                                break;
11703                                        case 26:
11704                                                {
11705                                                setState(1322);
11706                                                headTagOpen();
11707                                                }
11708                                                break;
11709                                        case 27:
11710                                                {
11711                                                setState(1323);
11712                                                htmlTagOpen();
11713                                                }
11714                                                break;
11715                                        case 28:
11716                                                {
11717                                                setState(1324);
11718                                                optionTagOpen();
11719                                                }
11720                                                break;
11721                                        case 29:
11722                                                {
11723                                                setState(1325);
11724                                                tbodyTagOpen();
11725                                                }
11726                                                break;
11727                                        case 30:
11728                                                {
11729                                                setState(1326);
11730                                                tfootTagOpen();
11731                                                }
11732                                                break;
11733                                        case 31:
11734                                                {
11735                                                {
11736                                                setState(1327);
11737                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11738                                                setState(1328);
11739                                                match(LEADING_ASTERISK);
11740                                                }
11741                                                }
11742                                                break;
11743                                        case 32:
11744                                                {
11745                                                setState(1329);
11746                                                htmlComment();
11747                                                }
11748                                                break;
11749                                        case 33:
11750                                                {
11751                                                setState(1330);
11752                                                match(CDATA);
11753                                                }
11754                                                break;
11755                                        case 34:
11756                                                {
11757                                                setState(1331);
11758                                                match(NEWLINE);
11759                                                }
11760                                                break;
11761                                        case 35:
11762                                                {
11763                                                setState(1332);
11764                                                text();
11765                                                }
11766                                                break;
11767                                        case 36:
11768                                                {
11769                                                setState(1333);
11770                                                javadocInlineTag();
11771                                                }
11772                                                break;
11773                                        }
11774                                        } 
11775                                }
11776                                setState(1338);
11777                                _errHandler.sync(this);
11778                                _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11779                        }
11780                        setState(1339);
11781                        theadTagClose();
11782                        }
11783                }
11784                catch (RecognitionException re) {
11785                        _localctx.exception = re;
11786                        _errHandler.reportError(this, re);
11787                        _errHandler.recover(this, re);
11788                }
11789                finally {
11790                        exitRule();
11791                }
11792                return _localctx;
11793        }
11794
11795        public static class SingletonElementContext extends ParserRuleContext {
11796                public SingletonTagContext singletonTag() {
11797                        return getRuleContext(SingletonTagContext.class,0);
11798                }
11799                public AreaTagContext areaTag() {
11800                        return getRuleContext(AreaTagContext.class,0);
11801                }
11802                public BaseTagContext baseTag() {
11803                        return getRuleContext(BaseTagContext.class,0);
11804                }
11805                public BasefontTagContext basefontTag() {
11806                        return getRuleContext(BasefontTagContext.class,0);
11807                }
11808                public BrTagContext brTag() {
11809                        return getRuleContext(BrTagContext.class,0);
11810                }
11811                public ColTagContext colTag() {
11812                        return getRuleContext(ColTagContext.class,0);
11813                }
11814                public FrameTagContext frameTag() {
11815                        return getRuleContext(FrameTagContext.class,0);
11816                }
11817                public HrTagContext hrTag() {
11818                        return getRuleContext(HrTagContext.class,0);
11819                }
11820                public ImgTagContext imgTag() {
11821                        return getRuleContext(ImgTagContext.class,0);
11822                }
11823                public InputTagContext inputTag() {
11824                        return getRuleContext(InputTagContext.class,0);
11825                }
11826                public IsindexTagContext isindexTag() {
11827                        return getRuleContext(IsindexTagContext.class,0);
11828                }
11829                public LinkTagContext linkTag() {
11830                        return getRuleContext(LinkTagContext.class,0);
11831                }
11832                public MetaTagContext metaTag() {
11833                        return getRuleContext(MetaTagContext.class,0);
11834                }
11835                public ParamTagContext paramTag() {
11836                        return getRuleContext(ParamTagContext.class,0);
11837                }
11838                public WrongSinletonTagContext wrongSinletonTag() {
11839                        return getRuleContext(WrongSinletonTagContext.class,0);
11840                }
11841                public SingletonElementContext(ParserRuleContext parent, int invokingState) {
11842                        super(parent, invokingState);
11843                }
11844                @Override public int getRuleIndex() { return RULE_singletonElement; }
11845                @Override
11846                public void enterRule(ParseTreeListener listener) {
11847                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this);
11848                }
11849                @Override
11850                public void exitRule(ParseTreeListener listener) {
11851                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this);
11852                }
11853                @Override
11854                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11855                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this);
11856                        else return visitor.visitChildren(this);
11857                }
11858        }
11859
11860        public final SingletonElementContext singletonElement() throws RecognitionException {
11861                SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState());
11862                enterRule(_localctx, 102, RULE_singletonElement);
11863                try {
11864                        setState(1356);
11865                        _errHandler.sync(this);
11866                        switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
11867                        case 1:
11868                                enterOuterAlt(_localctx, 1);
11869                                {
11870                                setState(1341);
11871                                singletonTag();
11872                                }
11873                                break;
11874                        case 2:
11875                                enterOuterAlt(_localctx, 2);
11876                                {
11877                                setState(1342);
11878                                areaTag();
11879                                }
11880                                break;
11881                        case 3:
11882                                enterOuterAlt(_localctx, 3);
11883                                {
11884                                setState(1343);
11885                                baseTag();
11886                                }
11887                                break;
11888                        case 4:
11889                                enterOuterAlt(_localctx, 4);
11890                                {
11891                                setState(1344);
11892                                basefontTag();
11893                                }
11894                                break;
11895                        case 5:
11896                                enterOuterAlt(_localctx, 5);
11897                                {
11898                                setState(1345);
11899                                brTag();
11900                                }
11901                                break;
11902                        case 6:
11903                                enterOuterAlt(_localctx, 6);
11904                                {
11905                                setState(1346);
11906                                colTag();
11907                                }
11908                                break;
11909                        case 7:
11910                                enterOuterAlt(_localctx, 7);
11911                                {
11912                                setState(1347);
11913                                frameTag();
11914                                }
11915                                break;
11916                        case 8:
11917                                enterOuterAlt(_localctx, 8);
11918                                {
11919                                setState(1348);
11920                                hrTag();
11921                                }
11922                                break;
11923                        case 9:
11924                                enterOuterAlt(_localctx, 9);
11925                                {
11926                                setState(1349);
11927                                imgTag();
11928                                }
11929                                break;
11930                        case 10:
11931                                enterOuterAlt(_localctx, 10);
11932                                {
11933                                setState(1350);
11934                                inputTag();
11935                                }
11936                                break;
11937                        case 11:
11938                                enterOuterAlt(_localctx, 11);
11939                                {
11940                                setState(1351);
11941                                isindexTag();
11942                                }
11943                                break;
11944                        case 12:
11945                                enterOuterAlt(_localctx, 12);
11946                                {
11947                                setState(1352);
11948                                linkTag();
11949                                }
11950                                break;
11951                        case 13:
11952                                enterOuterAlt(_localctx, 13);
11953                                {
11954                                setState(1353);
11955                                metaTag();
11956                                }
11957                                break;
11958                        case 14:
11959                                enterOuterAlt(_localctx, 14);
11960                                {
11961                                setState(1354);
11962                                paramTag();
11963                                }
11964                                break;
11965                        case 15:
11966                                enterOuterAlt(_localctx, 15);
11967                                {
11968                                setState(1355);
11969                                wrongSinletonTag();
11970                                }
11971                                break;
11972                        }
11973                }
11974                catch (RecognitionException re) {
11975                        _localctx.exception = re;
11976                        _errHandler.reportError(this, re);
11977                        _errHandler.recover(this, re);
11978                }
11979                finally {
11980                        exitRule();
11981                }
11982                return _localctx;
11983        }
11984
11985        public static class SingletonTagContext extends ParserRuleContext {
11986                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11987                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11988                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
11989                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
11990                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
11991                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
11992                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
11993                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
11994                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
11995                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
11996                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
11997                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
11998                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
11999                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
12000                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
12001                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
12002                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
12003                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
12004                public List<AttributeContext> attribute() {
12005                        return getRuleContexts(AttributeContext.class);
12006                }
12007                public AttributeContext attribute(int i) {
12008                        return getRuleContext(AttributeContext.class,i);
12009                }
12010                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12011                public TerminalNode NEWLINE(int i) {
12012                        return getToken(JavadocParser.NEWLINE, i);
12013                }
12014                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12015                public TerminalNode LEADING_ASTERISK(int i) {
12016                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12017                }
12018                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12019                public TerminalNode WS(int i) {
12020                        return getToken(JavadocParser.WS, i);
12021                }
12022                public SingletonTagContext(ParserRuleContext parent, int invokingState) {
12023                        super(parent, invokingState);
12024                }
12025                @Override public int getRuleIndex() { return RULE_singletonTag; }
12026                @Override
12027                public void enterRule(ParseTreeListener listener) {
12028                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this);
12029                }
12030                @Override
12031                public void exitRule(ParseTreeListener listener) {
12032                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this);
12033                }
12034                @Override
12035                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12036                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this);
12037                        else return visitor.visitChildren(this);
12038                }
12039        }
12040
12041        public final SingletonTagContext singletonTag() throws RecognitionException {
12042                SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState());
12043                enterRule(_localctx, 104, RULE_singletonTag);
12044                int _la;
12045                try {
12046                        enterOuterAlt(_localctx, 1);
12047                        {
12048                        setState(1358);
12049                        match(OPEN);
12050                        setState(1359);
12051                        _la = _input.LA(1);
12052                        if ( !(((((_la - 59)) & ~0x3f) == 0 && ((1L << (_la - 59)) & ((1L << (P_HTML_TAG_NAME - 59)) | (1L << (LI_HTML_TAG_NAME - 59)) | (1L << (TR_HTML_TAG_NAME - 59)) | (1L << (TD_HTML_TAG_NAME - 59)) | (1L << (TH_HTML_TAG_NAME - 59)) | (1L << (BODY_HTML_TAG_NAME - 59)) | (1L << (COLGROUP_HTML_TAG_NAME - 59)) | (1L << (DD_HTML_TAG_NAME - 59)) | (1L << (DT_HTML_TAG_NAME - 59)) | (1L << (HEAD_HTML_TAG_NAME - 59)) | (1L << (HTML_HTML_TAG_NAME - 59)) | (1L << (OPTION_HTML_TAG_NAME - 59)) | (1L << (TBODY_HTML_TAG_NAME - 59)) | (1L << (TFOOT_HTML_TAG_NAME - 59)) | (1L << (THEAD_HTML_TAG_NAME - 59)) | (1L << (HTML_TAG_NAME - 59)))) != 0)) ) {
12053                        _errHandler.recoverInline(this);
12054                        }
12055                        else {
12056                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12057                                _errHandler.reportMatch(this);
12058                                consume();
12059                        }
12060                        setState(1366);
12061                        _errHandler.sync(this);
12062                        _la = _input.LA(1);
12063                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12064                                {
12065                                setState(1364);
12066                                _errHandler.sync(this);
12067                                switch (_input.LA(1)) {
12068                                case HTML_TAG_NAME:
12069                                        {
12070                                        setState(1360);
12071                                        attribute();
12072                                        }
12073                                        break;
12074                                case NEWLINE:
12075                                        {
12076                                        setState(1361);
12077                                        match(NEWLINE);
12078                                        }
12079                                        break;
12080                                case LEADING_ASTERISK:
12081                                        {
12082                                        setState(1362);
12083                                        match(LEADING_ASTERISK);
12084                                        }
12085                                        break;
12086                                case WS:
12087                                        {
12088                                        setState(1363);
12089                                        match(WS);
12090                                        }
12091                                        break;
12092                                default:
12093                                        throw new NoViableAltException(this);
12094                                }
12095                                }
12096                                setState(1368);
12097                                _errHandler.sync(this);
12098                                _la = _input.LA(1);
12099                        }
12100                        setState(1369);
12101                        match(SLASH_CLOSE);
12102                        }
12103                }
12104                catch (RecognitionException re) {
12105                        _localctx.exception = re;
12106                        _errHandler.reportError(this, re);
12107                        _errHandler.recover(this, re);
12108                }
12109                finally {
12110                        exitRule();
12111                }
12112                return _localctx;
12113        }
12114
12115        public static class AreaTagContext extends ParserRuleContext {
12116                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12117                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
12118                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12119                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12120                public List<AttributeContext> attribute() {
12121                        return getRuleContexts(AttributeContext.class);
12122                }
12123                public AttributeContext attribute(int i) {
12124                        return getRuleContext(AttributeContext.class,i);
12125                }
12126                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12127                public TerminalNode NEWLINE(int i) {
12128                        return getToken(JavadocParser.NEWLINE, i);
12129                }
12130                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12131                public TerminalNode LEADING_ASTERISK(int i) {
12132                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12133                }
12134                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12135                public TerminalNode WS(int i) {
12136                        return getToken(JavadocParser.WS, i);
12137                }
12138                public AreaTagContext(ParserRuleContext parent, int invokingState) {
12139                        super(parent, invokingState);
12140                }
12141                @Override public int getRuleIndex() { return RULE_areaTag; }
12142                @Override
12143                public void enterRule(ParseTreeListener listener) {
12144                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this);
12145                }
12146                @Override
12147                public void exitRule(ParseTreeListener listener) {
12148                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this);
12149                }
12150                @Override
12151                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12152                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this);
12153                        else return visitor.visitChildren(this);
12154                }
12155        }
12156
12157        public final AreaTagContext areaTag() throws RecognitionException {
12158                AreaTagContext _localctx = new AreaTagContext(_ctx, getState());
12159                enterRule(_localctx, 106, RULE_areaTag);
12160                int _la;
12161                try {
12162                        enterOuterAlt(_localctx, 1);
12163                        {
12164                        setState(1371);
12165                        match(OPEN);
12166                        setState(1372);
12167                        match(AREA_HTML_TAG_NAME);
12168                        setState(1379);
12169                        _errHandler.sync(this);
12170                        _la = _input.LA(1);
12171                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12172                                {
12173                                setState(1377);
12174                                _errHandler.sync(this);
12175                                switch (_input.LA(1)) {
12176                                case HTML_TAG_NAME:
12177                                        {
12178                                        setState(1373);
12179                                        attribute();
12180                                        }
12181                                        break;
12182                                case NEWLINE:
12183                                        {
12184                                        setState(1374);
12185                                        match(NEWLINE);
12186                                        }
12187                                        break;
12188                                case LEADING_ASTERISK:
12189                                        {
12190                                        setState(1375);
12191                                        match(LEADING_ASTERISK);
12192                                        }
12193                                        break;
12194                                case WS:
12195                                        {
12196                                        setState(1376);
12197                                        match(WS);
12198                                        }
12199                                        break;
12200                                default:
12201                                        throw new NoViableAltException(this);
12202                                }
12203                                }
12204                                setState(1381);
12205                                _errHandler.sync(this);
12206                                _la = _input.LA(1);
12207                        }
12208                        setState(1382);
12209                        _la = _input.LA(1);
12210                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12211                        _errHandler.recoverInline(this);
12212                        }
12213                        else {
12214                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12215                                _errHandler.reportMatch(this);
12216                                consume();
12217                        }
12218                        }
12219                }
12220                catch (RecognitionException re) {
12221                        _localctx.exception = re;
12222                        _errHandler.reportError(this, re);
12223                        _errHandler.recover(this, re);
12224                }
12225                finally {
12226                        exitRule();
12227                }
12228                return _localctx;
12229        }
12230
12231        public static class BaseTagContext extends ParserRuleContext {
12232                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12233                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
12234                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12235                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12236                public List<AttributeContext> attribute() {
12237                        return getRuleContexts(AttributeContext.class);
12238                }
12239                public AttributeContext attribute(int i) {
12240                        return getRuleContext(AttributeContext.class,i);
12241                }
12242                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12243                public TerminalNode NEWLINE(int i) {
12244                        return getToken(JavadocParser.NEWLINE, i);
12245                }
12246                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12247                public TerminalNode LEADING_ASTERISK(int i) {
12248                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12249                }
12250                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12251                public TerminalNode WS(int i) {
12252                        return getToken(JavadocParser.WS, i);
12253                }
12254                public BaseTagContext(ParserRuleContext parent, int invokingState) {
12255                        super(parent, invokingState);
12256                }
12257                @Override public int getRuleIndex() { return RULE_baseTag; }
12258                @Override
12259                public void enterRule(ParseTreeListener listener) {
12260                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this);
12261                }
12262                @Override
12263                public void exitRule(ParseTreeListener listener) {
12264                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this);
12265                }
12266                @Override
12267                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12268                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this);
12269                        else return visitor.visitChildren(this);
12270                }
12271        }
12272
12273        public final BaseTagContext baseTag() throws RecognitionException {
12274                BaseTagContext _localctx = new BaseTagContext(_ctx, getState());
12275                enterRule(_localctx, 108, RULE_baseTag);
12276                int _la;
12277                try {
12278                        enterOuterAlt(_localctx, 1);
12279                        {
12280                        setState(1384);
12281                        match(OPEN);
12282                        setState(1385);
12283                        match(BASE_HTML_TAG_NAME);
12284                        setState(1392);
12285                        _errHandler.sync(this);
12286                        _la = _input.LA(1);
12287                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12288                                {
12289                                setState(1390);
12290                                _errHandler.sync(this);
12291                                switch (_input.LA(1)) {
12292                                case HTML_TAG_NAME:
12293                                        {
12294                                        setState(1386);
12295                                        attribute();
12296                                        }
12297                                        break;
12298                                case NEWLINE:
12299                                        {
12300                                        setState(1387);
12301                                        match(NEWLINE);
12302                                        }
12303                                        break;
12304                                case LEADING_ASTERISK:
12305                                        {
12306                                        setState(1388);
12307                                        match(LEADING_ASTERISK);
12308                                        }
12309                                        break;
12310                                case WS:
12311                                        {
12312                                        setState(1389);
12313                                        match(WS);
12314                                        }
12315                                        break;
12316                                default:
12317                                        throw new NoViableAltException(this);
12318                                }
12319                                }
12320                                setState(1394);
12321                                _errHandler.sync(this);
12322                                _la = _input.LA(1);
12323                        }
12324                        setState(1395);
12325                        _la = _input.LA(1);
12326                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12327                        _errHandler.recoverInline(this);
12328                        }
12329                        else {
12330                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12331                                _errHandler.reportMatch(this);
12332                                consume();
12333                        }
12334                        }
12335                }
12336                catch (RecognitionException re) {
12337                        _localctx.exception = re;
12338                        _errHandler.reportError(this, re);
12339                        _errHandler.recover(this, re);
12340                }
12341                finally {
12342                        exitRule();
12343                }
12344                return _localctx;
12345        }
12346
12347        public static class BasefontTagContext extends ParserRuleContext {
12348                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12349                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
12350                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12351                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12352                public List<AttributeContext> attribute() {
12353                        return getRuleContexts(AttributeContext.class);
12354                }
12355                public AttributeContext attribute(int i) {
12356                        return getRuleContext(AttributeContext.class,i);
12357                }
12358                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12359                public TerminalNode NEWLINE(int i) {
12360                        return getToken(JavadocParser.NEWLINE, i);
12361                }
12362                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12363                public TerminalNode LEADING_ASTERISK(int i) {
12364                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12365                }
12366                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12367                public TerminalNode WS(int i) {
12368                        return getToken(JavadocParser.WS, i);
12369                }
12370                public BasefontTagContext(ParserRuleContext parent, int invokingState) {
12371                        super(parent, invokingState);
12372                }
12373                @Override public int getRuleIndex() { return RULE_basefontTag; }
12374                @Override
12375                public void enterRule(ParseTreeListener listener) {
12376                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this);
12377                }
12378                @Override
12379                public void exitRule(ParseTreeListener listener) {
12380                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this);
12381                }
12382                @Override
12383                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12384                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this);
12385                        else return visitor.visitChildren(this);
12386                }
12387        }
12388
12389        public final BasefontTagContext basefontTag() throws RecognitionException {
12390                BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState());
12391                enterRule(_localctx, 110, RULE_basefontTag);
12392                int _la;
12393                try {
12394                        enterOuterAlt(_localctx, 1);
12395                        {
12396                        setState(1397);
12397                        match(OPEN);
12398                        setState(1398);
12399                        match(BASEFONT_HTML_TAG_NAME);
12400                        setState(1405);
12401                        _errHandler.sync(this);
12402                        _la = _input.LA(1);
12403                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12404                                {
12405                                setState(1403);
12406                                _errHandler.sync(this);
12407                                switch (_input.LA(1)) {
12408                                case HTML_TAG_NAME:
12409                                        {
12410                                        setState(1399);
12411                                        attribute();
12412                                        }
12413                                        break;
12414                                case NEWLINE:
12415                                        {
12416                                        setState(1400);
12417                                        match(NEWLINE);
12418                                        }
12419                                        break;
12420                                case LEADING_ASTERISK:
12421                                        {
12422                                        setState(1401);
12423                                        match(LEADING_ASTERISK);
12424                                        }
12425                                        break;
12426                                case WS:
12427                                        {
12428                                        setState(1402);
12429                                        match(WS);
12430                                        }
12431                                        break;
12432                                default:
12433                                        throw new NoViableAltException(this);
12434                                }
12435                                }
12436                                setState(1407);
12437                                _errHandler.sync(this);
12438                                _la = _input.LA(1);
12439                        }
12440                        setState(1408);
12441                        _la = _input.LA(1);
12442                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12443                        _errHandler.recoverInline(this);
12444                        }
12445                        else {
12446                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12447                                _errHandler.reportMatch(this);
12448                                consume();
12449                        }
12450                        }
12451                }
12452                catch (RecognitionException re) {
12453                        _localctx.exception = re;
12454                        _errHandler.reportError(this, re);
12455                        _errHandler.recover(this, re);
12456                }
12457                finally {
12458                        exitRule();
12459                }
12460                return _localctx;
12461        }
12462
12463        public static class BrTagContext extends ParserRuleContext {
12464                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12465                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
12466                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12467                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12468                public List<AttributeContext> attribute() {
12469                        return getRuleContexts(AttributeContext.class);
12470                }
12471                public AttributeContext attribute(int i) {
12472                        return getRuleContext(AttributeContext.class,i);
12473                }
12474                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12475                public TerminalNode NEWLINE(int i) {
12476                        return getToken(JavadocParser.NEWLINE, i);
12477                }
12478                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12479                public TerminalNode LEADING_ASTERISK(int i) {
12480                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12481                }
12482                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12483                public TerminalNode WS(int i) {
12484                        return getToken(JavadocParser.WS, i);
12485                }
12486                public BrTagContext(ParserRuleContext parent, int invokingState) {
12487                        super(parent, invokingState);
12488                }
12489                @Override public int getRuleIndex() { return RULE_brTag; }
12490                @Override
12491                public void enterRule(ParseTreeListener listener) {
12492                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this);
12493                }
12494                @Override
12495                public void exitRule(ParseTreeListener listener) {
12496                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this);
12497                }
12498                @Override
12499                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12500                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this);
12501                        else return visitor.visitChildren(this);
12502                }
12503        }
12504
12505        public final BrTagContext brTag() throws RecognitionException {
12506                BrTagContext _localctx = new BrTagContext(_ctx, getState());
12507                enterRule(_localctx, 112, RULE_brTag);
12508                int _la;
12509                try {
12510                        enterOuterAlt(_localctx, 1);
12511                        {
12512                        setState(1410);
12513                        match(OPEN);
12514                        setState(1411);
12515                        match(BR_HTML_TAG_NAME);
12516                        setState(1418);
12517                        _errHandler.sync(this);
12518                        _la = _input.LA(1);
12519                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12520                                {
12521                                setState(1416);
12522                                _errHandler.sync(this);
12523                                switch (_input.LA(1)) {
12524                                case HTML_TAG_NAME:
12525                                        {
12526                                        setState(1412);
12527                                        attribute();
12528                                        }
12529                                        break;
12530                                case NEWLINE:
12531                                        {
12532                                        setState(1413);
12533                                        match(NEWLINE);
12534                                        }
12535                                        break;
12536                                case LEADING_ASTERISK:
12537                                        {
12538                                        setState(1414);
12539                                        match(LEADING_ASTERISK);
12540                                        }
12541                                        break;
12542                                case WS:
12543                                        {
12544                                        setState(1415);
12545                                        match(WS);
12546                                        }
12547                                        break;
12548                                default:
12549                                        throw new NoViableAltException(this);
12550                                }
12551                                }
12552                                setState(1420);
12553                                _errHandler.sync(this);
12554                                _la = _input.LA(1);
12555                        }
12556                        setState(1421);
12557                        _la = _input.LA(1);
12558                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12559                        _errHandler.recoverInline(this);
12560                        }
12561                        else {
12562                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12563                                _errHandler.reportMatch(this);
12564                                consume();
12565                        }
12566                        }
12567                }
12568                catch (RecognitionException re) {
12569                        _localctx.exception = re;
12570                        _errHandler.reportError(this, re);
12571                        _errHandler.recover(this, re);
12572                }
12573                finally {
12574                        exitRule();
12575                }
12576                return _localctx;
12577        }
12578
12579        public static class ColTagContext extends ParserRuleContext {
12580                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12581                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
12582                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12583                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12584                public List<AttributeContext> attribute() {
12585                        return getRuleContexts(AttributeContext.class);
12586                }
12587                public AttributeContext attribute(int i) {
12588                        return getRuleContext(AttributeContext.class,i);
12589                }
12590                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12591                public TerminalNode NEWLINE(int i) {
12592                        return getToken(JavadocParser.NEWLINE, i);
12593                }
12594                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12595                public TerminalNode LEADING_ASTERISK(int i) {
12596                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12597                }
12598                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12599                public TerminalNode WS(int i) {
12600                        return getToken(JavadocParser.WS, i);
12601                }
12602                public ColTagContext(ParserRuleContext parent, int invokingState) {
12603                        super(parent, invokingState);
12604                }
12605                @Override public int getRuleIndex() { return RULE_colTag; }
12606                @Override
12607                public void enterRule(ParseTreeListener listener) {
12608                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this);
12609                }
12610                @Override
12611                public void exitRule(ParseTreeListener listener) {
12612                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this);
12613                }
12614                @Override
12615                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12616                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this);
12617                        else return visitor.visitChildren(this);
12618                }
12619        }
12620
12621        public final ColTagContext colTag() throws RecognitionException {
12622                ColTagContext _localctx = new ColTagContext(_ctx, getState());
12623                enterRule(_localctx, 114, RULE_colTag);
12624                int _la;
12625                try {
12626                        enterOuterAlt(_localctx, 1);
12627                        {
12628                        setState(1423);
12629                        match(OPEN);
12630                        setState(1424);
12631                        match(COL_HTML_TAG_NAME);
12632                        setState(1431);
12633                        _errHandler.sync(this);
12634                        _la = _input.LA(1);
12635                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12636                                {
12637                                setState(1429);
12638                                _errHandler.sync(this);
12639                                switch (_input.LA(1)) {
12640                                case HTML_TAG_NAME:
12641                                        {
12642                                        setState(1425);
12643                                        attribute();
12644                                        }
12645                                        break;
12646                                case NEWLINE:
12647                                        {
12648                                        setState(1426);
12649                                        match(NEWLINE);
12650                                        }
12651                                        break;
12652                                case LEADING_ASTERISK:
12653                                        {
12654                                        setState(1427);
12655                                        match(LEADING_ASTERISK);
12656                                        }
12657                                        break;
12658                                case WS:
12659                                        {
12660                                        setState(1428);
12661                                        match(WS);
12662                                        }
12663                                        break;
12664                                default:
12665                                        throw new NoViableAltException(this);
12666                                }
12667                                }
12668                                setState(1433);
12669                                _errHandler.sync(this);
12670                                _la = _input.LA(1);
12671                        }
12672                        setState(1434);
12673                        _la = _input.LA(1);
12674                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12675                        _errHandler.recoverInline(this);
12676                        }
12677                        else {
12678                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12679                                _errHandler.reportMatch(this);
12680                                consume();
12681                        }
12682                        }
12683                }
12684                catch (RecognitionException re) {
12685                        _localctx.exception = re;
12686                        _errHandler.reportError(this, re);
12687                        _errHandler.recover(this, re);
12688                }
12689                finally {
12690                        exitRule();
12691                }
12692                return _localctx;
12693        }
12694
12695        public static class FrameTagContext extends ParserRuleContext {
12696                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12697                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
12698                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12699                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12700                public List<AttributeContext> attribute() {
12701                        return getRuleContexts(AttributeContext.class);
12702                }
12703                public AttributeContext attribute(int i) {
12704                        return getRuleContext(AttributeContext.class,i);
12705                }
12706                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12707                public TerminalNode NEWLINE(int i) {
12708                        return getToken(JavadocParser.NEWLINE, i);
12709                }
12710                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12711                public TerminalNode LEADING_ASTERISK(int i) {
12712                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12713                }
12714                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12715                public TerminalNode WS(int i) {
12716                        return getToken(JavadocParser.WS, i);
12717                }
12718                public FrameTagContext(ParserRuleContext parent, int invokingState) {
12719                        super(parent, invokingState);
12720                }
12721                @Override public int getRuleIndex() { return RULE_frameTag; }
12722                @Override
12723                public void enterRule(ParseTreeListener listener) {
12724                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this);
12725                }
12726                @Override
12727                public void exitRule(ParseTreeListener listener) {
12728                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this);
12729                }
12730                @Override
12731                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12732                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this);
12733                        else return visitor.visitChildren(this);
12734                }
12735        }
12736
12737        public final FrameTagContext frameTag() throws RecognitionException {
12738                FrameTagContext _localctx = new FrameTagContext(_ctx, getState());
12739                enterRule(_localctx, 116, RULE_frameTag);
12740                int _la;
12741                try {
12742                        enterOuterAlt(_localctx, 1);
12743                        {
12744                        setState(1436);
12745                        match(OPEN);
12746                        setState(1437);
12747                        match(FRAME_HTML_TAG_NAME);
12748                        setState(1444);
12749                        _errHandler.sync(this);
12750                        _la = _input.LA(1);
12751                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12752                                {
12753                                setState(1442);
12754                                _errHandler.sync(this);
12755                                switch (_input.LA(1)) {
12756                                case HTML_TAG_NAME:
12757                                        {
12758                                        setState(1438);
12759                                        attribute();
12760                                        }
12761                                        break;
12762                                case NEWLINE:
12763                                        {
12764                                        setState(1439);
12765                                        match(NEWLINE);
12766                                        }
12767                                        break;
12768                                case LEADING_ASTERISK:
12769                                        {
12770                                        setState(1440);
12771                                        match(LEADING_ASTERISK);
12772                                        }
12773                                        break;
12774                                case WS:
12775                                        {
12776                                        setState(1441);
12777                                        match(WS);
12778                                        }
12779                                        break;
12780                                default:
12781                                        throw new NoViableAltException(this);
12782                                }
12783                                }
12784                                setState(1446);
12785                                _errHandler.sync(this);
12786                                _la = _input.LA(1);
12787                        }
12788                        setState(1447);
12789                        _la = _input.LA(1);
12790                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12791                        _errHandler.recoverInline(this);
12792                        }
12793                        else {
12794                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12795                                _errHandler.reportMatch(this);
12796                                consume();
12797                        }
12798                        }
12799                }
12800                catch (RecognitionException re) {
12801                        _localctx.exception = re;
12802                        _errHandler.reportError(this, re);
12803                        _errHandler.recover(this, re);
12804                }
12805                finally {
12806                        exitRule();
12807                }
12808                return _localctx;
12809        }
12810
12811        public static class HrTagContext extends ParserRuleContext {
12812                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12813                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
12814                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12815                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12816                public List<AttributeContext> attribute() {
12817                        return getRuleContexts(AttributeContext.class);
12818                }
12819                public AttributeContext attribute(int i) {
12820                        return getRuleContext(AttributeContext.class,i);
12821                }
12822                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12823                public TerminalNode NEWLINE(int i) {
12824                        return getToken(JavadocParser.NEWLINE, i);
12825                }
12826                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12827                public TerminalNode LEADING_ASTERISK(int i) {
12828                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12829                }
12830                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12831                public TerminalNode WS(int i) {
12832                        return getToken(JavadocParser.WS, i);
12833                }
12834                public HrTagContext(ParserRuleContext parent, int invokingState) {
12835                        super(parent, invokingState);
12836                }
12837                @Override public int getRuleIndex() { return RULE_hrTag; }
12838                @Override
12839                public void enterRule(ParseTreeListener listener) {
12840                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this);
12841                }
12842                @Override
12843                public void exitRule(ParseTreeListener listener) {
12844                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this);
12845                }
12846                @Override
12847                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12848                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this);
12849                        else return visitor.visitChildren(this);
12850                }
12851        }
12852
12853        public final HrTagContext hrTag() throws RecognitionException {
12854                HrTagContext _localctx = new HrTagContext(_ctx, getState());
12855                enterRule(_localctx, 118, RULE_hrTag);
12856                int _la;
12857                try {
12858                        enterOuterAlt(_localctx, 1);
12859                        {
12860                        setState(1449);
12861                        match(OPEN);
12862                        setState(1450);
12863                        match(HR_HTML_TAG_NAME);
12864                        setState(1457);
12865                        _errHandler.sync(this);
12866                        _la = _input.LA(1);
12867                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12868                                {
12869                                setState(1455);
12870                                _errHandler.sync(this);
12871                                switch (_input.LA(1)) {
12872                                case HTML_TAG_NAME:
12873                                        {
12874                                        setState(1451);
12875                                        attribute();
12876                                        }
12877                                        break;
12878                                case NEWLINE:
12879                                        {
12880                                        setState(1452);
12881                                        match(NEWLINE);
12882                                        }
12883                                        break;
12884                                case LEADING_ASTERISK:
12885                                        {
12886                                        setState(1453);
12887                                        match(LEADING_ASTERISK);
12888                                        }
12889                                        break;
12890                                case WS:
12891                                        {
12892                                        setState(1454);
12893                                        match(WS);
12894                                        }
12895                                        break;
12896                                default:
12897                                        throw new NoViableAltException(this);
12898                                }
12899                                }
12900                                setState(1459);
12901                                _errHandler.sync(this);
12902                                _la = _input.LA(1);
12903                        }
12904                        setState(1460);
12905                        _la = _input.LA(1);
12906                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12907                        _errHandler.recoverInline(this);
12908                        }
12909                        else {
12910                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12911                                _errHandler.reportMatch(this);
12912                                consume();
12913                        }
12914                        }
12915                }
12916                catch (RecognitionException re) {
12917                        _localctx.exception = re;
12918                        _errHandler.reportError(this, re);
12919                        _errHandler.recover(this, re);
12920                }
12921                finally {
12922                        exitRule();
12923                }
12924                return _localctx;
12925        }
12926
12927        public static class ImgTagContext extends ParserRuleContext {
12928                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12929                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
12930                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12931                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12932                public List<AttributeContext> attribute() {
12933                        return getRuleContexts(AttributeContext.class);
12934                }
12935                public AttributeContext attribute(int i) {
12936                        return getRuleContext(AttributeContext.class,i);
12937                }
12938                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12939                public TerminalNode NEWLINE(int i) {
12940                        return getToken(JavadocParser.NEWLINE, i);
12941                }
12942                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12943                public TerminalNode LEADING_ASTERISK(int i) {
12944                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12945                }
12946                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12947                public TerminalNode WS(int i) {
12948                        return getToken(JavadocParser.WS, i);
12949                }
12950                public ImgTagContext(ParserRuleContext parent, int invokingState) {
12951                        super(parent, invokingState);
12952                }
12953                @Override public int getRuleIndex() { return RULE_imgTag; }
12954                @Override
12955                public void enterRule(ParseTreeListener listener) {
12956                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this);
12957                }
12958                @Override
12959                public void exitRule(ParseTreeListener listener) {
12960                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this);
12961                }
12962                @Override
12963                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12964                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this);
12965                        else return visitor.visitChildren(this);
12966                }
12967        }
12968
12969        public final ImgTagContext imgTag() throws RecognitionException {
12970                ImgTagContext _localctx = new ImgTagContext(_ctx, getState());
12971                enterRule(_localctx, 120, RULE_imgTag);
12972                int _la;
12973                try {
12974                        enterOuterAlt(_localctx, 1);
12975                        {
12976                        setState(1462);
12977                        match(OPEN);
12978                        setState(1463);
12979                        match(IMG_HTML_TAG_NAME);
12980                        setState(1470);
12981                        _errHandler.sync(this);
12982                        _la = _input.LA(1);
12983                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12984                                {
12985                                setState(1468);
12986                                _errHandler.sync(this);
12987                                switch (_input.LA(1)) {
12988                                case HTML_TAG_NAME:
12989                                        {
12990                                        setState(1464);
12991                                        attribute();
12992                                        }
12993                                        break;
12994                                case NEWLINE:
12995                                        {
12996                                        setState(1465);
12997                                        match(NEWLINE);
12998                                        }
12999                                        break;
13000                                case LEADING_ASTERISK:
13001                                        {
13002                                        setState(1466);
13003                                        match(LEADING_ASTERISK);
13004                                        }
13005                                        break;
13006                                case WS:
13007                                        {
13008                                        setState(1467);
13009                                        match(WS);
13010                                        }
13011                                        break;
13012                                default:
13013                                        throw new NoViableAltException(this);
13014                                }
13015                                }
13016                                setState(1472);
13017                                _errHandler.sync(this);
13018                                _la = _input.LA(1);
13019                        }
13020                        setState(1473);
13021                        _la = _input.LA(1);
13022                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13023                        _errHandler.recoverInline(this);
13024                        }
13025                        else {
13026                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13027                                _errHandler.reportMatch(this);
13028                                consume();
13029                        }
13030                        }
13031                }
13032                catch (RecognitionException re) {
13033                        _localctx.exception = re;
13034                        _errHandler.reportError(this, re);
13035                        _errHandler.recover(this, re);
13036                }
13037                finally {
13038                        exitRule();
13039                }
13040                return _localctx;
13041        }
13042
13043        public static class InputTagContext extends ParserRuleContext {
13044                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13045                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13046                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13047                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13048                public List<AttributeContext> attribute() {
13049                        return getRuleContexts(AttributeContext.class);
13050                }
13051                public AttributeContext attribute(int i) {
13052                        return getRuleContext(AttributeContext.class,i);
13053                }
13054                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13055                public TerminalNode NEWLINE(int i) {
13056                        return getToken(JavadocParser.NEWLINE, i);
13057                }
13058                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13059                public TerminalNode LEADING_ASTERISK(int i) {
13060                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13061                }
13062                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13063                public TerminalNode WS(int i) {
13064                        return getToken(JavadocParser.WS, i);
13065                }
13066                public InputTagContext(ParserRuleContext parent, int invokingState) {
13067                        super(parent, invokingState);
13068                }
13069                @Override public int getRuleIndex() { return RULE_inputTag; }
13070                @Override
13071                public void enterRule(ParseTreeListener listener) {
13072                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this);
13073                }
13074                @Override
13075                public void exitRule(ParseTreeListener listener) {
13076                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this);
13077                }
13078                @Override
13079                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13080                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this);
13081                        else return visitor.visitChildren(this);
13082                }
13083        }
13084
13085        public final InputTagContext inputTag() throws RecognitionException {
13086                InputTagContext _localctx = new InputTagContext(_ctx, getState());
13087                enterRule(_localctx, 122, RULE_inputTag);
13088                int _la;
13089                try {
13090                        enterOuterAlt(_localctx, 1);
13091                        {
13092                        setState(1475);
13093                        match(OPEN);
13094                        setState(1476);
13095                        match(INPUT_HTML_TAG_NAME);
13096                        setState(1483);
13097                        _errHandler.sync(this);
13098                        _la = _input.LA(1);
13099                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13100                                {
13101                                setState(1481);
13102                                _errHandler.sync(this);
13103                                switch (_input.LA(1)) {
13104                                case HTML_TAG_NAME:
13105                                        {
13106                                        setState(1477);
13107                                        attribute();
13108                                        }
13109                                        break;
13110                                case NEWLINE:
13111                                        {
13112                                        setState(1478);
13113                                        match(NEWLINE);
13114                                        }
13115                                        break;
13116                                case LEADING_ASTERISK:
13117                                        {
13118                                        setState(1479);
13119                                        match(LEADING_ASTERISK);
13120                                        }
13121                                        break;
13122                                case WS:
13123                                        {
13124                                        setState(1480);
13125                                        match(WS);
13126                                        }
13127                                        break;
13128                                default:
13129                                        throw new NoViableAltException(this);
13130                                }
13131                                }
13132                                setState(1485);
13133                                _errHandler.sync(this);
13134                                _la = _input.LA(1);
13135                        }
13136                        setState(1486);
13137                        _la = _input.LA(1);
13138                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13139                        _errHandler.recoverInline(this);
13140                        }
13141                        else {
13142                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13143                                _errHandler.reportMatch(this);
13144                                consume();
13145                        }
13146                        }
13147                }
13148                catch (RecognitionException re) {
13149                        _localctx.exception = re;
13150                        _errHandler.reportError(this, re);
13151                        _errHandler.recover(this, re);
13152                }
13153                finally {
13154                        exitRule();
13155                }
13156                return _localctx;
13157        }
13158
13159        public static class IsindexTagContext extends ParserRuleContext {
13160                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13161                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13162                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13163                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13164                public List<AttributeContext> attribute() {
13165                        return getRuleContexts(AttributeContext.class);
13166                }
13167                public AttributeContext attribute(int i) {
13168                        return getRuleContext(AttributeContext.class,i);
13169                }
13170                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13171                public TerminalNode NEWLINE(int i) {
13172                        return getToken(JavadocParser.NEWLINE, i);
13173                }
13174                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13175                public TerminalNode LEADING_ASTERISK(int i) {
13176                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13177                }
13178                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13179                public TerminalNode WS(int i) {
13180                        return getToken(JavadocParser.WS, i);
13181                }
13182                public IsindexTagContext(ParserRuleContext parent, int invokingState) {
13183                        super(parent, invokingState);
13184                }
13185                @Override public int getRuleIndex() { return RULE_isindexTag; }
13186                @Override
13187                public void enterRule(ParseTreeListener listener) {
13188                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this);
13189                }
13190                @Override
13191                public void exitRule(ParseTreeListener listener) {
13192                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this);
13193                }
13194                @Override
13195                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13196                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this);
13197                        else return visitor.visitChildren(this);
13198                }
13199        }
13200
13201        public final IsindexTagContext isindexTag() throws RecognitionException {
13202                IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState());
13203                enterRule(_localctx, 124, RULE_isindexTag);
13204                int _la;
13205                try {
13206                        enterOuterAlt(_localctx, 1);
13207                        {
13208                        setState(1488);
13209                        match(OPEN);
13210                        setState(1489);
13211                        match(ISINDEX_HTML_TAG_NAME);
13212                        setState(1496);
13213                        _errHandler.sync(this);
13214                        _la = _input.LA(1);
13215                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13216                                {
13217                                setState(1494);
13218                                _errHandler.sync(this);
13219                                switch (_input.LA(1)) {
13220                                case HTML_TAG_NAME:
13221                                        {
13222                                        setState(1490);
13223                                        attribute();
13224                                        }
13225                                        break;
13226                                case NEWLINE:
13227                                        {
13228                                        setState(1491);
13229                                        match(NEWLINE);
13230                                        }
13231                                        break;
13232                                case LEADING_ASTERISK:
13233                                        {
13234                                        setState(1492);
13235                                        match(LEADING_ASTERISK);
13236                                        }
13237                                        break;
13238                                case WS:
13239                                        {
13240                                        setState(1493);
13241                                        match(WS);
13242                                        }
13243                                        break;
13244                                default:
13245                                        throw new NoViableAltException(this);
13246                                }
13247                                }
13248                                setState(1498);
13249                                _errHandler.sync(this);
13250                                _la = _input.LA(1);
13251                        }
13252                        setState(1499);
13253                        _la = _input.LA(1);
13254                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13255                        _errHandler.recoverInline(this);
13256                        }
13257                        else {
13258                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13259                                _errHandler.reportMatch(this);
13260                                consume();
13261                        }
13262                        }
13263                }
13264                catch (RecognitionException re) {
13265                        _localctx.exception = re;
13266                        _errHandler.reportError(this, re);
13267                        _errHandler.recover(this, re);
13268                }
13269                finally {
13270                        exitRule();
13271                }
13272                return _localctx;
13273        }
13274
13275        public static class LinkTagContext extends ParserRuleContext {
13276                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13277                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13278                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13279                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13280                public List<AttributeContext> attribute() {
13281                        return getRuleContexts(AttributeContext.class);
13282                }
13283                public AttributeContext attribute(int i) {
13284                        return getRuleContext(AttributeContext.class,i);
13285                }
13286                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13287                public TerminalNode NEWLINE(int i) {
13288                        return getToken(JavadocParser.NEWLINE, i);
13289                }
13290                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13291                public TerminalNode LEADING_ASTERISK(int i) {
13292                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13293                }
13294                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13295                public TerminalNode WS(int i) {
13296                        return getToken(JavadocParser.WS, i);
13297                }
13298                public LinkTagContext(ParserRuleContext parent, int invokingState) {
13299                        super(parent, invokingState);
13300                }
13301                @Override public int getRuleIndex() { return RULE_linkTag; }
13302                @Override
13303                public void enterRule(ParseTreeListener listener) {
13304                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this);
13305                }
13306                @Override
13307                public void exitRule(ParseTreeListener listener) {
13308                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this);
13309                }
13310                @Override
13311                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13312                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this);
13313                        else return visitor.visitChildren(this);
13314                }
13315        }
13316
13317        public final LinkTagContext linkTag() throws RecognitionException {
13318                LinkTagContext _localctx = new LinkTagContext(_ctx, getState());
13319                enterRule(_localctx, 126, RULE_linkTag);
13320                int _la;
13321                try {
13322                        enterOuterAlt(_localctx, 1);
13323                        {
13324                        setState(1501);
13325                        match(OPEN);
13326                        setState(1502);
13327                        match(LINK_HTML_TAG_NAME);
13328                        setState(1509);
13329                        _errHandler.sync(this);
13330                        _la = _input.LA(1);
13331                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13332                                {
13333                                setState(1507);
13334                                _errHandler.sync(this);
13335                                switch (_input.LA(1)) {
13336                                case HTML_TAG_NAME:
13337                                        {
13338                                        setState(1503);
13339                                        attribute();
13340                                        }
13341                                        break;
13342                                case NEWLINE:
13343                                        {
13344                                        setState(1504);
13345                                        match(NEWLINE);
13346                                        }
13347                                        break;
13348                                case LEADING_ASTERISK:
13349                                        {
13350                                        setState(1505);
13351                                        match(LEADING_ASTERISK);
13352                                        }
13353                                        break;
13354                                case WS:
13355                                        {
13356                                        setState(1506);
13357                                        match(WS);
13358                                        }
13359                                        break;
13360                                default:
13361                                        throw new NoViableAltException(this);
13362                                }
13363                                }
13364                                setState(1511);
13365                                _errHandler.sync(this);
13366                                _la = _input.LA(1);
13367                        }
13368                        setState(1512);
13369                        _la = _input.LA(1);
13370                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13371                        _errHandler.recoverInline(this);
13372                        }
13373                        else {
13374                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13375                                _errHandler.reportMatch(this);
13376                                consume();
13377                        }
13378                        }
13379                }
13380                catch (RecognitionException re) {
13381                        _localctx.exception = re;
13382                        _errHandler.reportError(this, re);
13383                        _errHandler.recover(this, re);
13384                }
13385                finally {
13386                        exitRule();
13387                }
13388                return _localctx;
13389        }
13390
13391        public static class MetaTagContext extends ParserRuleContext {
13392                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13393                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13394                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13395                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13396                public List<AttributeContext> attribute() {
13397                        return getRuleContexts(AttributeContext.class);
13398                }
13399                public AttributeContext attribute(int i) {
13400                        return getRuleContext(AttributeContext.class,i);
13401                }
13402                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13403                public TerminalNode NEWLINE(int i) {
13404                        return getToken(JavadocParser.NEWLINE, i);
13405                }
13406                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13407                public TerminalNode LEADING_ASTERISK(int i) {
13408                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13409                }
13410                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13411                public TerminalNode WS(int i) {
13412                        return getToken(JavadocParser.WS, i);
13413                }
13414                public MetaTagContext(ParserRuleContext parent, int invokingState) {
13415                        super(parent, invokingState);
13416                }
13417                @Override public int getRuleIndex() { return RULE_metaTag; }
13418                @Override
13419                public void enterRule(ParseTreeListener listener) {
13420                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this);
13421                }
13422                @Override
13423                public void exitRule(ParseTreeListener listener) {
13424                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this);
13425                }
13426                @Override
13427                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13428                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this);
13429                        else return visitor.visitChildren(this);
13430                }
13431        }
13432
13433        public final MetaTagContext metaTag() throws RecognitionException {
13434                MetaTagContext _localctx = new MetaTagContext(_ctx, getState());
13435                enterRule(_localctx, 128, RULE_metaTag);
13436                int _la;
13437                try {
13438                        enterOuterAlt(_localctx, 1);
13439                        {
13440                        setState(1514);
13441                        match(OPEN);
13442                        setState(1515);
13443                        match(META_HTML_TAG_NAME);
13444                        setState(1522);
13445                        _errHandler.sync(this);
13446                        _la = _input.LA(1);
13447                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13448                                {
13449                                setState(1520);
13450                                _errHandler.sync(this);
13451                                switch (_input.LA(1)) {
13452                                case HTML_TAG_NAME:
13453                                        {
13454                                        setState(1516);
13455                                        attribute();
13456                                        }
13457                                        break;
13458                                case NEWLINE:
13459                                        {
13460                                        setState(1517);
13461                                        match(NEWLINE);
13462                                        }
13463                                        break;
13464                                case LEADING_ASTERISK:
13465                                        {
13466                                        setState(1518);
13467                                        match(LEADING_ASTERISK);
13468                                        }
13469                                        break;
13470                                case WS:
13471                                        {
13472                                        setState(1519);
13473                                        match(WS);
13474                                        }
13475                                        break;
13476                                default:
13477                                        throw new NoViableAltException(this);
13478                                }
13479                                }
13480                                setState(1524);
13481                                _errHandler.sync(this);
13482                                _la = _input.LA(1);
13483                        }
13484                        setState(1525);
13485                        _la = _input.LA(1);
13486                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13487                        _errHandler.recoverInline(this);
13488                        }
13489                        else {
13490                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13491                                _errHandler.reportMatch(this);
13492                                consume();
13493                        }
13494                        }
13495                }
13496                catch (RecognitionException re) {
13497                        _localctx.exception = re;
13498                        _errHandler.reportError(this, re);
13499                        _errHandler.recover(this, re);
13500                }
13501                finally {
13502                        exitRule();
13503                }
13504                return _localctx;
13505        }
13506
13507        public static class ParamTagContext extends ParserRuleContext {
13508                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13509                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13510                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13511                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13512                public List<AttributeContext> attribute() {
13513                        return getRuleContexts(AttributeContext.class);
13514                }
13515                public AttributeContext attribute(int i) {
13516                        return getRuleContext(AttributeContext.class,i);
13517                }
13518                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13519                public TerminalNode NEWLINE(int i) {
13520                        return getToken(JavadocParser.NEWLINE, i);
13521                }
13522                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13523                public TerminalNode LEADING_ASTERISK(int i) {
13524                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13525                }
13526                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13527                public TerminalNode WS(int i) {
13528                        return getToken(JavadocParser.WS, i);
13529                }
13530                public ParamTagContext(ParserRuleContext parent, int invokingState) {
13531                        super(parent, invokingState);
13532                }
13533                @Override public int getRuleIndex() { return RULE_paramTag; }
13534                @Override
13535                public void enterRule(ParseTreeListener listener) {
13536                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this);
13537                }
13538                @Override
13539                public void exitRule(ParseTreeListener listener) {
13540                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this);
13541                }
13542                @Override
13543                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13544                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this);
13545                        else return visitor.visitChildren(this);
13546                }
13547        }
13548
13549        public final ParamTagContext paramTag() throws RecognitionException {
13550                ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
13551                enterRule(_localctx, 130, RULE_paramTag);
13552                int _la;
13553                try {
13554                        enterOuterAlt(_localctx, 1);
13555                        {
13556                        setState(1527);
13557                        match(OPEN);
13558                        setState(1528);
13559                        match(PARAM_HTML_TAG_NAME);
13560                        setState(1535);
13561                        _errHandler.sync(this);
13562                        _la = _input.LA(1);
13563                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13564                                {
13565                                setState(1533);
13566                                _errHandler.sync(this);
13567                                switch (_input.LA(1)) {
13568                                case HTML_TAG_NAME:
13569                                        {
13570                                        setState(1529);
13571                                        attribute();
13572                                        }
13573                                        break;
13574                                case NEWLINE:
13575                                        {
13576                                        setState(1530);
13577                                        match(NEWLINE);
13578                                        }
13579                                        break;
13580                                case LEADING_ASTERISK:
13581                                        {
13582                                        setState(1531);
13583                                        match(LEADING_ASTERISK);
13584                                        }
13585                                        break;
13586                                case WS:
13587                                        {
13588                                        setState(1532);
13589                                        match(WS);
13590                                        }
13591                                        break;
13592                                default:
13593                                        throw new NoViableAltException(this);
13594                                }
13595                                }
13596                                setState(1537);
13597                                _errHandler.sync(this);
13598                                _la = _input.LA(1);
13599                        }
13600                        setState(1538);
13601                        _la = _input.LA(1);
13602                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13603                        _errHandler.recoverInline(this);
13604                        }
13605                        else {
13606                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13607                                _errHandler.reportMatch(this);
13608                                consume();
13609                        }
13610                        }
13611                }
13612                catch (RecognitionException re) {
13613                        _localctx.exception = re;
13614                        _errHandler.reportError(this, re);
13615                        _errHandler.recover(this, re);
13616                }
13617                finally {
13618                        exitRule();
13619                }
13620                return _localctx;
13621        }
13622
13623        public static class WrongSinletonTagContext extends ParserRuleContext {
13624                public SingletonTagNameContext singletonTagName;
13625                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13626                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
13627                public SingletonTagNameContext singletonTagName() {
13628                        return getRuleContext(SingletonTagNameContext.class,0);
13629                }
13630                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13631                public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) {
13632                        super(parent, invokingState);
13633                }
13634                @Override public int getRuleIndex() { return RULE_wrongSinletonTag; }
13635                @Override
13636                public void enterRule(ParseTreeListener listener) {
13637                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this);
13638                }
13639                @Override
13640                public void exitRule(ParseTreeListener listener) {
13641                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this);
13642                }
13643                @Override
13644                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13645                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this);
13646                        else return visitor.visitChildren(this);
13647                }
13648        }
13649
13650        public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException {
13651                WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState());
13652                enterRule(_localctx, 132, RULE_wrongSinletonTag);
13653                try {
13654                        enterOuterAlt(_localctx, 1);
13655                        {
13656                        setState(1540);
13657                        match(OPEN);
13658                        setState(1541);
13659                        match(SLASH);
13660                        setState(1542);
13661                        ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName();
13662                        setState(1543);
13663                        match(CLOSE);
13664                        notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null),
13665                                                     "javadoc.wrong.singleton.html.tag", null);
13666                        }
13667                }
13668                catch (RecognitionException re) {
13669                        _localctx.exception = re;
13670                        _errHandler.reportError(this, re);
13671                        _errHandler.recover(this, re);
13672                }
13673                finally {
13674                        exitRule();
13675                }
13676                return _localctx;
13677        }
13678
13679        public static class SingletonTagNameContext extends ParserRuleContext {
13680                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
13681                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
13682                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
13683                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
13684                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
13685                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
13686                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
13687                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
13688                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13689                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13690                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13691                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13692                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13693                public SingletonTagNameContext(ParserRuleContext parent, int invokingState) {
13694                        super(parent, invokingState);
13695                }
13696                @Override public int getRuleIndex() { return RULE_singletonTagName; }
13697                @Override
13698                public void enterRule(ParseTreeListener listener) {
13699                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this);
13700                }
13701                @Override
13702                public void exitRule(ParseTreeListener listener) {
13703                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this);
13704                }
13705                @Override
13706                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13707                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this);
13708                        else return visitor.visitChildren(this);
13709                }
13710        }
13711
13712        public final SingletonTagNameContext singletonTagName() throws RecognitionException {
13713                SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState());
13714                enterRule(_localctx, 134, RULE_singletonTagName);
13715                int _la;
13716                try {
13717                        enterOuterAlt(_localctx, 1);
13718                        {
13719                        setState(1546);
13720                        _la = _input.LA(1);
13721                        if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)))) != 0)) ) {
13722                        _errHandler.recoverInline(this);
13723                        }
13724                        else {
13725                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13726                                _errHandler.reportMatch(this);
13727                                consume();
13728                        }
13729                        }
13730                }
13731                catch (RecognitionException re) {
13732                        _localctx.exception = re;
13733                        _errHandler.reportError(this, re);
13734                        _errHandler.recover(this, re);
13735                }
13736                finally {
13737                        exitRule();
13738                }
13739                return _localctx;
13740        }
13741
13742        public static class DescriptionContext extends ParserRuleContext {
13743                public List<HtmlCommentContext> htmlComment() {
13744                        return getRuleContexts(HtmlCommentContext.class);
13745                }
13746                public HtmlCommentContext htmlComment(int i) {
13747                        return getRuleContext(HtmlCommentContext.class,i);
13748                }
13749                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
13750                public TerminalNode CDATA(int i) {
13751                        return getToken(JavadocParser.CDATA, i);
13752                }
13753                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13754                public TerminalNode NEWLINE(int i) {
13755                        return getToken(JavadocParser.NEWLINE, i);
13756                }
13757                public List<TextContext> text() {
13758                        return getRuleContexts(TextContext.class);
13759                }
13760                public TextContext text(int i) {
13761                        return getRuleContext(TextContext.class,i);
13762                }
13763                public List<JavadocInlineTagContext> javadocInlineTag() {
13764                        return getRuleContexts(JavadocInlineTagContext.class);
13765                }
13766                public JavadocInlineTagContext javadocInlineTag(int i) {
13767                        return getRuleContext(JavadocInlineTagContext.class,i);
13768                }
13769                public List<HtmlElementContext> htmlElement() {
13770                        return getRuleContexts(HtmlElementContext.class);
13771                }
13772                public HtmlElementContext htmlElement(int i) {
13773                        return getRuleContext(HtmlElementContext.class,i);
13774                }
13775                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13776                public TerminalNode LEADING_ASTERISK(int i) {
13777                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13778                }
13779                public DescriptionContext(ParserRuleContext parent, int invokingState) {
13780                        super(parent, invokingState);
13781                }
13782                @Override public int getRuleIndex() { return RULE_description; }
13783                @Override
13784                public void enterRule(ParseTreeListener listener) {
13785                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
13786                }
13787                @Override
13788                public void exitRule(ParseTreeListener listener) {
13789                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
13790                }
13791                @Override
13792                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13793                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
13794                        else return visitor.visitChildren(this);
13795                }
13796        }
13797
13798        public final DescriptionContext description() throws RecognitionException {
13799                DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
13800                enterRule(_localctx, 136, RULE_description);
13801                try {
13802                        int _alt;
13803                        enterOuterAlt(_localctx, 1);
13804                        {
13805                        setState(1556); 
13806                        _errHandler.sync(this);
13807                        _alt = 1;
13808                        do {
13809                                switch (_alt) {
13810                                case 1:
13811                                        {
13812                                        setState(1556);
13813                                        _errHandler.sync(this);
13814                                        switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
13815                                        case 1:
13816                                                {
13817                                                {
13818                                                setState(1548);
13819                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
13820                                                setState(1549);
13821                                                match(LEADING_ASTERISK);
13822                                                }
13823                                                }
13824                                                break;
13825                                        case 2:
13826                                                {
13827                                                setState(1550);
13828                                                htmlComment();
13829                                                }
13830                                                break;
13831                                        case 3:
13832                                                {
13833                                                setState(1551);
13834                                                match(CDATA);
13835                                                }
13836                                                break;
13837                                        case 4:
13838                                                {
13839                                                setState(1552);
13840                                                match(NEWLINE);
13841                                                }
13842                                                break;
13843                                        case 5:
13844                                                {
13845                                                setState(1553);
13846                                                text();
13847                                                }
13848                                                break;
13849                                        case 6:
13850                                                {
13851                                                setState(1554);
13852                                                javadocInlineTag();
13853                                                }
13854                                                break;
13855                                        case 7:
13856                                                {
13857                                                setState(1555);
13858                                                htmlElement();
13859                                                }
13860                                                break;
13861                                        }
13862                                        }
13863                                        break;
13864                                default:
13865                                        throw new NoViableAltException(this);
13866                                }
13867                                setState(1558); 
13868                                _errHandler.sync(this);
13869                                _alt = getInterpreter().adaptivePredict(_input,122,_ctx);
13870                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13871                        }
13872                }
13873                catch (RecognitionException re) {
13874                        _localctx.exception = re;
13875                        _errHandler.reportError(this, re);
13876                        _errHandler.recover(this, re);
13877                }
13878                finally {
13879                        exitRule();
13880                }
13881                return _localctx;
13882        }
13883
13884        public static class ReferenceContext extends ParserRuleContext {
13885                public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); }
13886                public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); }
13887                public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); }
13888                public ParametersContext parameters() {
13889                        return getRuleContext(ParametersContext.class,0);
13890                }
13891                public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); }
13892                public TerminalNode DOT(int i) {
13893                        return getToken(JavadocParser.DOT, i);
13894                }
13895                public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); }
13896                public TerminalNode CLASS(int i) {
13897                        return getToken(JavadocParser.CLASS, i);
13898                }
13899                public ReferenceContext(ParserRuleContext parent, int invokingState) {
13900                        super(parent, invokingState);
13901                }
13902                @Override public int getRuleIndex() { return RULE_reference; }
13903                @Override
13904                public void enterRule(ParseTreeListener listener) {
13905                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this);
13906                }
13907                @Override
13908                public void exitRule(ParseTreeListener listener) {
13909                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this);
13910                }
13911                @Override
13912                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13913                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this);
13914                        else return visitor.visitChildren(this);
13915                }
13916        }
13917
13918        public final ReferenceContext reference() throws RecognitionException {
13919                ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
13920                enterRule(_localctx, 138, RULE_reference);
13921                int _la;
13922                try {
13923                        int _alt;
13924                        enterOuterAlt(_localctx, 1);
13925                        {
13926                        setState(1597);
13927                        _errHandler.sync(this);
13928                        switch (_input.LA(1)) {
13929                        case PACKAGE:
13930                                {
13931                                setState(1560);
13932                                match(PACKAGE);
13933                                setState(1564);
13934                                _errHandler.sync(this);
13935                                _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13936                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13937                                        if ( _alt==1 ) {
13938                                                {
13939                                                {
13940                                                setState(1561);
13941                                                _la = _input.LA(1);
13942                                                if ( !(_la==DOT || _la==CLASS) ) {
13943                                                _errHandler.recoverInline(this);
13944                                                }
13945                                                else {
13946                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13947                                                        _errHandler.reportMatch(this);
13948                                                        consume();
13949                                                }
13950                                                }
13951                                                } 
13952                                        }
13953                                        setState(1566);
13954                                        _errHandler.sync(this);
13955                                        _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13956                                }
13957                                setState(1568);
13958                                _errHandler.sync(this);
13959                                switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
13960                                case 1:
13961                                        {
13962                                        setState(1567);
13963                                        match(HASH);
13964                                        }
13965                                        break;
13966                                }
13967                                setState(1571);
13968                                _errHandler.sync(this);
13969                                switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
13970                                case 1:
13971                                        {
13972                                        setState(1570);
13973                                        match(MEMBER);
13974                                        }
13975                                        break;
13976                                }
13977                                setState(1574);
13978                                _errHandler.sync(this);
13979                                switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
13980                                case 1:
13981                                        {
13982                                        setState(1573);
13983                                        parameters();
13984                                        }
13985                                        break;
13986                                }
13987                                }
13988                                break;
13989                        case DOT:
13990                        case CLASS:
13991                                {
13992                                setState(1577); 
13993                                _errHandler.sync(this);
13994                                _alt = 1;
13995                                do {
13996                                        switch (_alt) {
13997                                        case 1:
13998                                                {
13999                                                {
14000                                                setState(1576);
14001                                                _la = _input.LA(1);
14002                                                if ( !(_la==DOT || _la==CLASS) ) {
14003                                                _errHandler.recoverInline(this);
14004                                                }
14005                                                else {
14006                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14007                                                        _errHandler.reportMatch(this);
14008                                                        consume();
14009                                                }
14010                                                }
14011                                                }
14012                                                break;
14013                                        default:
14014                                                throw new NoViableAltException(this);
14015                                        }
14016                                        setState(1579); 
14017                                        _errHandler.sync(this);
14018                                        _alt = getInterpreter().adaptivePredict(_input,127,_ctx);
14019                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
14020                                setState(1582);
14021                                _errHandler.sync(this);
14022                                switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
14023                                case 1:
14024                                        {
14025                                        setState(1581);
14026                                        match(HASH);
14027                                        }
14028                                        break;
14029                                }
14030                                setState(1585);
14031                                _errHandler.sync(this);
14032                                switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
14033                                case 1:
14034                                        {
14035                                        setState(1584);
14036                                        match(MEMBER);
14037                                        }
14038                                        break;
14039                                }
14040                                setState(1588);
14041                                _errHandler.sync(this);
14042                                switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
14043                                case 1:
14044                                        {
14045                                        setState(1587);
14046                                        parameters();
14047                                        }
14048                                        break;
14049                                }
14050                                }
14051                                break;
14052                        case HASH:
14053                        case MEMBER:
14054                                {
14055                                setState(1591);
14056                                _errHandler.sync(this);
14057                                _la = _input.LA(1);
14058                                if (_la==HASH) {
14059                                        {
14060                                        setState(1590);
14061                                        match(HASH);
14062                                        }
14063                                }
14064
14065                                setState(1593);
14066                                match(MEMBER);
14067                                setState(1595);
14068                                _errHandler.sync(this);
14069                                switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
14070                                case 1:
14071                                        {
14072                                        setState(1594);
14073                                        parameters();
14074                                        }
14075                                        break;
14076                                }
14077                                }
14078                                break;
14079                        default:
14080                                throw new NoViableAltException(this);
14081                        }
14082                        }
14083                }
14084                catch (RecognitionException re) {
14085                        _localctx.exception = re;
14086                        _errHandler.reportError(this, re);
14087                        _errHandler.recover(this, re);
14088                }
14089                finally {
14090                        exitRule();
14091                }
14092                return _localctx;
14093        }
14094
14095        public static class ParametersContext extends ParserRuleContext {
14096                public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); }
14097                public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); }
14098                public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); }
14099                public TerminalNode ARGUMENT(int i) {
14100                        return getToken(JavadocParser.ARGUMENT, i);
14101                }
14102                public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); }
14103                public TerminalNode COMMA(int i) {
14104                        return getToken(JavadocParser.COMMA, i);
14105                }
14106                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14107                public TerminalNode WS(int i) {
14108                        return getToken(JavadocParser.WS, i);
14109                }
14110                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14111                public TerminalNode NEWLINE(int i) {
14112                        return getToken(JavadocParser.NEWLINE, i);
14113                }
14114                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14115                public TerminalNode LEADING_ASTERISK(int i) {
14116                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14117                }
14118                public ParametersContext(ParserRuleContext parent, int invokingState) {
14119                        super(parent, invokingState);
14120                }
14121                @Override public int getRuleIndex() { return RULE_parameters; }
14122                @Override
14123                public void enterRule(ParseTreeListener listener) {
14124                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this);
14125                }
14126                @Override
14127                public void exitRule(ParseTreeListener listener) {
14128                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this);
14129                }
14130                @Override
14131                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14132                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this);
14133                        else return visitor.visitChildren(this);
14134                }
14135        }
14136
14137        public final ParametersContext parameters() throws RecognitionException {
14138                ParametersContext _localctx = new ParametersContext(_ctx, getState());
14139                enterRule(_localctx, 140, RULE_parameters);
14140                int _la;
14141                try {
14142                        enterOuterAlt(_localctx, 1);
14143                        {
14144                        setState(1599);
14145                        match(LEFT_BRACE);
14146                        setState(1603);
14147                        _errHandler.sync(this);
14148                        _la = _input.LA(1);
14149                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) {
14150                                {
14151                                {
14152                                setState(1600);
14153                                _la = _input.LA(1);
14154                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) {
14155                                _errHandler.recoverInline(this);
14156                                }
14157                                else {
14158                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14159                                        _errHandler.reportMatch(this);
14160                                        consume();
14161                                }
14162                                }
14163                                }
14164                                setState(1605);
14165                                _errHandler.sync(this);
14166                                _la = _input.LA(1);
14167                        }
14168                        setState(1606);
14169                        match(RIGHT_BRACE);
14170                        }
14171                }
14172                catch (RecognitionException re) {
14173                        _localctx.exception = re;
14174                        _errHandler.reportError(this, re);
14175                        _errHandler.recover(this, re);
14176                }
14177                finally {
14178                        exitRule();
14179                }
14180                return _localctx;
14181        }
14182
14183        public static class JavadocTagContext extends ParserRuleContext {
14184                public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); }
14185                public DescriptionContext description() {
14186                        return getRuleContext(DescriptionContext.class,0);
14187                }
14188                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14189                public TerminalNode WS(int i) {
14190                        return getToken(JavadocParser.WS, i);
14191                }
14192                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14193                public TerminalNode NEWLINE(int i) {
14194                        return getToken(JavadocParser.NEWLINE, i);
14195                }
14196                public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); }
14197                public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); }
14198                public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); }
14199                public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); }
14200                public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); }
14201                public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); }
14202                public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); }
14203                public ReferenceContext reference() {
14204                        return getRuleContext(ReferenceContext.class,0);
14205                }
14206                public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); }
14207                public TerminalNode STRING(int i) {
14208                        return getToken(JavadocParser.STRING, i);
14209                }
14210                public List<HtmlElementContext> htmlElement() {
14211                        return getRuleContexts(HtmlElementContext.class);
14212                }
14213                public HtmlElementContext htmlElement(int i) {
14214                        return getRuleContext(HtmlElementContext.class,i);
14215                }
14216                public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); }
14217                public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); }
14218                public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); }
14219                public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); }
14220                public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); }
14221                public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); }
14222                public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); }
14223                public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); }
14224                public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); }
14225                public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); }
14226                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14227                public JavadocTagContext(ParserRuleContext parent, int invokingState) {
14228                        super(parent, invokingState);
14229                }
14230                @Override public int getRuleIndex() { return RULE_javadocTag; }
14231                @Override
14232                public void enterRule(ParseTreeListener listener) {
14233                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this);
14234                }
14235                @Override
14236                public void exitRule(ParseTreeListener listener) {
14237                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this);
14238                }
14239                @Override
14240                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14241                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this);
14242                        else return visitor.visitChildren(this);
14243                }
14244        }
14245
14246        public final JavadocTagContext javadocTag() throws RecognitionException {
14247                JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState());
14248                enterRule(_localctx, 142, RULE_javadocTag);
14249                int _la;
14250                try {
14251                        int _alt;
14252                        setState(1802);
14253                        _errHandler.sync(this);
14254                        switch (_input.LA(1)) {
14255                        case AUTHOR_LITERAL:
14256                                enterOuterAlt(_localctx, 1);
14257                                {
14258                                setState(1608);
14259                                match(AUTHOR_LITERAL);
14260                                setState(1612);
14261                                _errHandler.sync(this);
14262                                _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14263                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14264                                        if ( _alt==1 ) {
14265                                                {
14266                                                {
14267                                                setState(1609);
14268                                                _la = _input.LA(1);
14269                                                if ( !(_la==WS || _la==NEWLINE) ) {
14270                                                _errHandler.recoverInline(this);
14271                                                }
14272                                                else {
14273                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14274                                                        _errHandler.reportMatch(this);
14275                                                        consume();
14276                                                }
14277                                                }
14278                                                } 
14279                                        }
14280                                        setState(1614);
14281                                        _errHandler.sync(this);
14282                                        _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14283                                }
14284                                setState(1616);
14285                                _errHandler.sync(this);
14286                                switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
14287                                case 1:
14288                                        {
14289                                        setState(1615);
14290                                        description();
14291                                        }
14292                                        break;
14293                                }
14294                                }
14295                                break;
14296                        case DEPRECATED_LITERAL:
14297                                enterOuterAlt(_localctx, 2);
14298                                {
14299                                setState(1618);
14300                                match(DEPRECATED_LITERAL);
14301                                setState(1622);
14302                                _errHandler.sync(this);
14303                                _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14304                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14305                                        if ( _alt==1 ) {
14306                                                {
14307                                                {
14308                                                setState(1619);
14309                                                _la = _input.LA(1);
14310                                                if ( !(_la==WS || _la==NEWLINE) ) {
14311                                                _errHandler.recoverInline(this);
14312                                                }
14313                                                else {
14314                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14315                                                        _errHandler.reportMatch(this);
14316                                                        consume();
14317                                                }
14318                                                }
14319                                                } 
14320                                        }
14321                                        setState(1624);
14322                                        _errHandler.sync(this);
14323                                        _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14324                                }
14325                                setState(1626);
14326                                _errHandler.sync(this);
14327                                switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
14328                                case 1:
14329                                        {
14330                                        setState(1625);
14331                                        description();
14332                                        }
14333                                        break;
14334                                }
14335                                }
14336                                break;
14337                        case EXCEPTION_LITERAL:
14338                                enterOuterAlt(_localctx, 3);
14339                                {
14340                                setState(1628);
14341                                match(EXCEPTION_LITERAL);
14342                                setState(1632);
14343                                _errHandler.sync(this);
14344                                _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14345                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14346                                        if ( _alt==1 ) {
14347                                                {
14348                                                {
14349                                                setState(1629);
14350                                                _la = _input.LA(1);
14351                                                if ( !(_la==WS || _la==NEWLINE) ) {
14352                                                _errHandler.recoverInline(this);
14353                                                }
14354                                                else {
14355                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14356                                                        _errHandler.reportMatch(this);
14357                                                        consume();
14358                                                }
14359                                                }
14360                                                } 
14361                                        }
14362                                        setState(1634);
14363                                        _errHandler.sync(this);
14364                                        _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14365                                }
14366                                setState(1636);
14367                                _errHandler.sync(this);
14368                                switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
14369                                case 1:
14370                                        {
14371                                        setState(1635);
14372                                        match(CLASS_NAME);
14373                                        }
14374                                        break;
14375                                }
14376                                setState(1641);
14377                                _errHandler.sync(this);
14378                                _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14379                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14380                                        if ( _alt==1 ) {
14381                                                {
14382                                                {
14383                                                setState(1638);
14384                                                _la = _input.LA(1);
14385                                                if ( !(_la==WS || _la==NEWLINE) ) {
14386                                                _errHandler.recoverInline(this);
14387                                                }
14388                                                else {
14389                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14390                                                        _errHandler.reportMatch(this);
14391                                                        consume();
14392                                                }
14393                                                }
14394                                                } 
14395                                        }
14396                                        setState(1643);
14397                                        _errHandler.sync(this);
14398                                        _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14399                                }
14400                                setState(1645);
14401                                _errHandler.sync(this);
14402                                switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
14403                                case 1:
14404                                        {
14405                                        setState(1644);
14406                                        description();
14407                                        }
14408                                        break;
14409                                }
14410                                }
14411                                break;
14412                        case PARAM_LITERAL:
14413                                enterOuterAlt(_localctx, 4);
14414                                {
14415                                setState(1647);
14416                                match(PARAM_LITERAL);
14417                                setState(1651);
14418                                _errHandler.sync(this);
14419                                _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14420                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14421                                        if ( _alt==1 ) {
14422                                                {
14423                                                {
14424                                                setState(1648);
14425                                                _la = _input.LA(1);
14426                                                if ( !(_la==WS || _la==NEWLINE) ) {
14427                                                _errHandler.recoverInline(this);
14428                                                }
14429                                                else {
14430                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14431                                                        _errHandler.reportMatch(this);
14432                                                        consume();
14433                                                }
14434                                                }
14435                                                } 
14436                                        }
14437                                        setState(1653);
14438                                        _errHandler.sync(this);
14439                                        _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14440                                }
14441                                setState(1655);
14442                                _errHandler.sync(this);
14443                                switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
14444                                case 1:
14445                                        {
14446                                        setState(1654);
14447                                        match(PARAMETER_NAME);
14448                                        }
14449                                        break;
14450                                }
14451                                setState(1660);
14452                                _errHandler.sync(this);
14453                                _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14454                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14455                                        if ( _alt==1 ) {
14456                                                {
14457                                                {
14458                                                setState(1657);
14459                                                _la = _input.LA(1);
14460                                                if ( !(_la==WS || _la==NEWLINE) ) {
14461                                                _errHandler.recoverInline(this);
14462                                                }
14463                                                else {
14464                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14465                                                        _errHandler.reportMatch(this);
14466                                                        consume();
14467                                                }
14468                                                }
14469                                                } 
14470                                        }
14471                                        setState(1662);
14472                                        _errHandler.sync(this);
14473                                        _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14474                                }
14475                                setState(1664);
14476                                _errHandler.sync(this);
14477                                switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
14478                                case 1:
14479                                        {
14480                                        setState(1663);
14481                                        description();
14482                                        }
14483                                        break;
14484                                }
14485                                }
14486                                break;
14487                        case RETURN_LITERAL:
14488                                enterOuterAlt(_localctx, 5);
14489                                {
14490                                setState(1666);
14491                                match(RETURN_LITERAL);
14492                                setState(1670);
14493                                _errHandler.sync(this);
14494                                _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14495                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14496                                        if ( _alt==1 ) {
14497                                                {
14498                                                {
14499                                                setState(1667);
14500                                                _la = _input.LA(1);
14501                                                if ( !(_la==WS || _la==NEWLINE) ) {
14502                                                _errHandler.recoverInline(this);
14503                                                }
14504                                                else {
14505                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14506                                                        _errHandler.reportMatch(this);
14507                                                        consume();
14508                                                }
14509                                                }
14510                                                } 
14511                                        }
14512                                        setState(1672);
14513                                        _errHandler.sync(this);
14514                                        _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14515                                }
14516                                setState(1674);
14517                                _errHandler.sync(this);
14518                                switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
14519                                case 1:
14520                                        {
14521                                        setState(1673);
14522                                        description();
14523                                        }
14524                                        break;
14525                                }
14526                                }
14527                                break;
14528                        case SEE_LITERAL:
14529                                enterOuterAlt(_localctx, 6);
14530                                {
14531                                setState(1676);
14532                                match(SEE_LITERAL);
14533                                setState(1680);
14534                                _errHandler.sync(this);
14535                                _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14536                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14537                                        if ( _alt==1 ) {
14538                                                {
14539                                                {
14540                                                setState(1677);
14541                                                _la = _input.LA(1);
14542                                                if ( !(_la==WS || _la==NEWLINE) ) {
14543                                                _errHandler.recoverInline(this);
14544                                                }
14545                                                else {
14546                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14547                                                        _errHandler.reportMatch(this);
14548                                                        consume();
14549                                                }
14550                                                }
14551                                                } 
14552                                        }
14553                                        setState(1682);
14554                                        _errHandler.sync(this);
14555                                        _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14556                                }
14557                                setState(1684);
14558                                _errHandler.sync(this);
14559                                switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
14560                                case 1:
14561                                        {
14562                                        setState(1683);
14563                                        reference();
14564                                        }
14565                                        break;
14566                                }
14567                                setState(1690);
14568                                _errHandler.sync(this);
14569                                _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14570                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14571                                        if ( _alt==1 ) {
14572                                                {
14573                                                setState(1688);
14574                                                _errHandler.sync(this);
14575                                                switch (_input.LA(1)) {
14576                                                case STRING:
14577                                                        {
14578                                                        setState(1686);
14579                                                        match(STRING);
14580                                                        }
14581                                                        break;
14582                                                case OPEN:
14583                                                        {
14584                                                        setState(1687);
14585                                                        htmlElement();
14586                                                        }
14587                                                        break;
14588                                                default:
14589                                                        throw new NoViableAltException(this);
14590                                                }
14591                                                } 
14592                                        }
14593                                        setState(1692);
14594                                        _errHandler.sync(this);
14595                                        _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14596                                }
14597                                setState(1696);
14598                                _errHandler.sync(this);
14599                                _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14600                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14601                                        if ( _alt==1 ) {
14602                                                {
14603                                                {
14604                                                setState(1693);
14605                                                _la = _input.LA(1);
14606                                                if ( !(_la==WS || _la==NEWLINE) ) {
14607                                                _errHandler.recoverInline(this);
14608                                                }
14609                                                else {
14610                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14611                                                        _errHandler.reportMatch(this);
14612                                                        consume();
14613                                                }
14614                                                }
14615                                                } 
14616                                        }
14617                                        setState(1698);
14618                                        _errHandler.sync(this);
14619                                        _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14620                                }
14621                                setState(1700);
14622                                _errHandler.sync(this);
14623                                switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
14624                                case 1:
14625                                        {
14626                                        setState(1699);
14627                                        description();
14628                                        }
14629                                        break;
14630                                }
14631                                }
14632                                break;
14633                        case SERIAL_LITERAL:
14634                                enterOuterAlt(_localctx, 7);
14635                                {
14636                                setState(1702);
14637                                match(SERIAL_LITERAL);
14638                                setState(1706);
14639                                _errHandler.sync(this);
14640                                _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14641                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14642                                        if ( _alt==1 ) {
14643                                                {
14644                                                {
14645                                                setState(1703);
14646                                                _la = _input.LA(1);
14647                                                if ( !(_la==WS || _la==NEWLINE) ) {
14648                                                _errHandler.recoverInline(this);
14649                                                }
14650                                                else {
14651                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14652                                                        _errHandler.reportMatch(this);
14653                                                        consume();
14654                                                }
14655                                                }
14656                                                } 
14657                                        }
14658                                        setState(1708);
14659                                        _errHandler.sync(this);
14660                                        _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14661                                }
14662                                setState(1710);
14663                                _errHandler.sync(this);
14664                                switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
14665                                case 1:
14666                                        {
14667                                        setState(1709);
14668                                        _la = _input.LA(1);
14669                                        if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) {
14670                                        _errHandler.recoverInline(this);
14671                                        }
14672                                        else {
14673                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14674                                                _errHandler.reportMatch(this);
14675                                                consume();
14676                                        }
14677                                        }
14678                                        break;
14679                                }
14680                                setState(1713);
14681                                _errHandler.sync(this);
14682                                switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
14683                                case 1:
14684                                        {
14685                                        setState(1712);
14686                                        description();
14687                                        }
14688                                        break;
14689                                }
14690                                }
14691                                break;
14692                        case SERIAL_DATA_LITERAL:
14693                                enterOuterAlt(_localctx, 8);
14694                                {
14695                                setState(1715);
14696                                match(SERIAL_DATA_LITERAL);
14697                                setState(1719);
14698                                _errHandler.sync(this);
14699                                _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14700                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14701                                        if ( _alt==1 ) {
14702                                                {
14703                                                {
14704                                                setState(1716);
14705                                                _la = _input.LA(1);
14706                                                if ( !(_la==WS || _la==NEWLINE) ) {
14707                                                _errHandler.recoverInline(this);
14708                                                }
14709                                                else {
14710                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14711                                                        _errHandler.reportMatch(this);
14712                                                        consume();
14713                                                }
14714                                                }
14715                                                } 
14716                                        }
14717                                        setState(1721);
14718                                        _errHandler.sync(this);
14719                                        _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14720                                }
14721                                setState(1723);
14722                                _errHandler.sync(this);
14723                                switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
14724                                case 1:
14725                                        {
14726                                        setState(1722);
14727                                        description();
14728                                        }
14729                                        break;
14730                                }
14731                                }
14732                                break;
14733                        case SERIAL_FIELD_LITERAL:
14734                                enterOuterAlt(_localctx, 9);
14735                                {
14736                                setState(1725);
14737                                match(SERIAL_FIELD_LITERAL);
14738                                setState(1729);
14739                                _errHandler.sync(this);
14740                                _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14741                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14742                                        if ( _alt==1 ) {
14743                                                {
14744                                                {
14745                                                setState(1726);
14746                                                _la = _input.LA(1);
14747                                                if ( !(_la==WS || _la==NEWLINE) ) {
14748                                                _errHandler.recoverInline(this);
14749                                                }
14750                                                else {
14751                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14752                                                        _errHandler.reportMatch(this);
14753                                                        consume();
14754                                                }
14755                                                }
14756                                                } 
14757                                        }
14758                                        setState(1731);
14759                                        _errHandler.sync(this);
14760                                        _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14761                                }
14762                                setState(1733);
14763                                _errHandler.sync(this);
14764                                switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
14765                                case 1:
14766                                        {
14767                                        setState(1732);
14768                                        match(FIELD_NAME);
14769                                        }
14770                                        break;
14771                                }
14772                                setState(1738);
14773                                _errHandler.sync(this);
14774                                _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14775                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14776                                        if ( _alt==1 ) {
14777                                                {
14778                                                {
14779                                                setState(1735);
14780                                                _la = _input.LA(1);
14781                                                if ( !(_la==WS || _la==NEWLINE) ) {
14782                                                _errHandler.recoverInline(this);
14783                                                }
14784                                                else {
14785                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14786                                                        _errHandler.reportMatch(this);
14787                                                        consume();
14788                                                }
14789                                                }
14790                                                } 
14791                                        }
14792                                        setState(1740);
14793                                        _errHandler.sync(this);
14794                                        _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14795                                }
14796                                setState(1742);
14797                                _errHandler.sync(this);
14798                                switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
14799                                case 1:
14800                                        {
14801                                        setState(1741);
14802                                        match(FIELD_TYPE);
14803                                        }
14804                                        break;
14805                                }
14806                                setState(1747);
14807                                _errHandler.sync(this);
14808                                _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14809                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14810                                        if ( _alt==1 ) {
14811                                                {
14812                                                {
14813                                                setState(1744);
14814                                                _la = _input.LA(1);
14815                                                if ( !(_la==WS || _la==NEWLINE) ) {
14816                                                _errHandler.recoverInline(this);
14817                                                }
14818                                                else {
14819                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14820                                                        _errHandler.reportMatch(this);
14821                                                        consume();
14822                                                }
14823                                                }
14824                                                } 
14825                                        }
14826                                        setState(1749);
14827                                        _errHandler.sync(this);
14828                                        _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14829                                }
14830                                setState(1751);
14831                                _errHandler.sync(this);
14832                                switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
14833                                case 1:
14834                                        {
14835                                        setState(1750);
14836                                        description();
14837                                        }
14838                                        break;
14839                                }
14840                                }
14841                                break;
14842                        case SINCE_LITERAL:
14843                                enterOuterAlt(_localctx, 10);
14844                                {
14845                                setState(1753);
14846                                match(SINCE_LITERAL);
14847                                setState(1757);
14848                                _errHandler.sync(this);
14849                                _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14850                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14851                                        if ( _alt==1 ) {
14852                                                {
14853                                                {
14854                                                setState(1754);
14855                                                _la = _input.LA(1);
14856                                                if ( !(_la==WS || _la==NEWLINE) ) {
14857                                                _errHandler.recoverInline(this);
14858                                                }
14859                                                else {
14860                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14861                                                        _errHandler.reportMatch(this);
14862                                                        consume();
14863                                                }
14864                                                }
14865                                                } 
14866                                        }
14867                                        setState(1759);
14868                                        _errHandler.sync(this);
14869                                        _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14870                                }
14871                                setState(1761);
14872                                _errHandler.sync(this);
14873                                switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
14874                                case 1:
14875                                        {
14876                                        setState(1760);
14877                                        description();
14878                                        }
14879                                        break;
14880                                }
14881                                }
14882                                break;
14883                        case THROWS_LITERAL:
14884                                enterOuterAlt(_localctx, 11);
14885                                {
14886                                setState(1763);
14887                                match(THROWS_LITERAL);
14888                                setState(1767);
14889                                _errHandler.sync(this);
14890                                _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14891                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14892                                        if ( _alt==1 ) {
14893                                                {
14894                                                {
14895                                                setState(1764);
14896                                                _la = _input.LA(1);
14897                                                if ( !(_la==WS || _la==NEWLINE) ) {
14898                                                _errHandler.recoverInline(this);
14899                                                }
14900                                                else {
14901                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14902                                                        _errHandler.reportMatch(this);
14903                                                        consume();
14904                                                }
14905                                                }
14906                                                } 
14907                                        }
14908                                        setState(1769);
14909                                        _errHandler.sync(this);
14910                                        _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14911                                }
14912                                setState(1771);
14913                                _errHandler.sync(this);
14914                                switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
14915                                case 1:
14916                                        {
14917                                        setState(1770);
14918                                        match(CLASS_NAME);
14919                                        }
14920                                        break;
14921                                }
14922                                setState(1776);
14923                                _errHandler.sync(this);
14924                                _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14925                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14926                                        if ( _alt==1 ) {
14927                                                {
14928                                                {
14929                                                setState(1773);
14930                                                _la = _input.LA(1);
14931                                                if ( !(_la==WS || _la==NEWLINE) ) {
14932                                                _errHandler.recoverInline(this);
14933                                                }
14934                                                else {
14935                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14936                                                        _errHandler.reportMatch(this);
14937                                                        consume();
14938                                                }
14939                                                }
14940                                                } 
14941                                        }
14942                                        setState(1778);
14943                                        _errHandler.sync(this);
14944                                        _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14945                                }
14946                                setState(1780);
14947                                _errHandler.sync(this);
14948                                switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
14949                                case 1:
14950                                        {
14951                                        setState(1779);
14952                                        description();
14953                                        }
14954                                        break;
14955                                }
14956                                }
14957                                break;
14958                        case VERSION_LITERAL:
14959                                enterOuterAlt(_localctx, 12);
14960                                {
14961                                setState(1782);
14962                                match(VERSION_LITERAL);
14963                                setState(1786);
14964                                _errHandler.sync(this);
14965                                _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14966                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14967                                        if ( _alt==1 ) {
14968                                                {
14969                                                {
14970                                                setState(1783);
14971                                                _la = _input.LA(1);
14972                                                if ( !(_la==WS || _la==NEWLINE) ) {
14973                                                _errHandler.recoverInline(this);
14974                                                }
14975                                                else {
14976                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14977                                                        _errHandler.reportMatch(this);
14978                                                        consume();
14979                                                }
14980                                                }
14981                                                } 
14982                                        }
14983                                        setState(1788);
14984                                        _errHandler.sync(this);
14985                                        _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14986                                }
14987                                setState(1790);
14988                                _errHandler.sync(this);
14989                                switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
14990                                case 1:
14991                                        {
14992                                        setState(1789);
14993                                        description();
14994                                        }
14995                                        break;
14996                                }
14997                                }
14998                                break;
14999                        case CUSTOM_NAME:
15000                                enterOuterAlt(_localctx, 13);
15001                                {
15002                                setState(1792);
15003                                match(CUSTOM_NAME);
15004                                setState(1796);
15005                                _errHandler.sync(this);
15006                                _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
15007                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
15008                                        if ( _alt==1 ) {
15009                                                {
15010                                                {
15011                                                setState(1793);
15012                                                _la = _input.LA(1);
15013                                                if ( !(_la==WS || _la==NEWLINE) ) {
15014                                                _errHandler.recoverInline(this);
15015                                                }
15016                                                else {
15017                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15018                                                        _errHandler.reportMatch(this);
15019                                                        consume();
15020                                                }
15021                                                }
15022                                                } 
15023                                        }
15024                                        setState(1798);
15025                                        _errHandler.sync(this);
15026                                        _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
15027                                }
15028                                setState(1800);
15029                                _errHandler.sync(this);
15030                                switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
15031                                case 1:
15032                                        {
15033                                        setState(1799);
15034                                        description();
15035                                        }
15036                                        break;
15037                                }
15038                                }
15039                                break;
15040                        default:
15041                                throw new NoViableAltException(this);
15042                        }
15043                }
15044                catch (RecognitionException re) {
15045                        _localctx.exception = re;
15046                        _errHandler.reportError(this, re);
15047                        _errHandler.recover(this, re);
15048                }
15049                finally {
15050                        exitRule();
15051                }
15052                return _localctx;
15053        }
15054
15055        public static class JavadocInlineTagContext extends ParserRuleContext {
15056                public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); }
15057                public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); }
15058                public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); }
15059                public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); }
15060                public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); }
15061                public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); }
15062                public ReferenceContext reference() {
15063                        return getRuleContext(ReferenceContext.class,0);
15064                }
15065                public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); }
15066                public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); }
15067                public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); }
15068                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
15069                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15070                public TerminalNode WS(int i) {
15071                        return getToken(JavadocParser.WS, i);
15072                }
15073                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15074                public TerminalNode NEWLINE(int i) {
15075                        return getToken(JavadocParser.NEWLINE, i);
15076                }
15077                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15078                public TerminalNode LEADING_ASTERISK(int i) {
15079                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15080                }
15081                public List<TextContext> text() {
15082                        return getRuleContexts(TextContext.class);
15083                }
15084                public TextContext text(int i) {
15085                        return getRuleContext(TextContext.class,i);
15086                }
15087                public DescriptionContext description() {
15088                        return getRuleContext(DescriptionContext.class,0);
15089                }
15090                public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) {
15091                        super(parent, invokingState);
15092                }
15093                @Override public int getRuleIndex() { return RULE_javadocInlineTag; }
15094                @Override
15095                public void enterRule(ParseTreeListener listener) {
15096                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this);
15097                }
15098                @Override
15099                public void exitRule(ParseTreeListener listener) {
15100                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this);
15101                }
15102                @Override
15103                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15104                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this);
15105                        else return visitor.visitChildren(this);
15106                }
15107        }
15108
15109        public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException {
15110                JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState());
15111                enterRule(_localctx, 144, RULE_javadocInlineTag);
15112                int _la;
15113                try {
15114                        int _alt;
15115                        enterOuterAlt(_localctx, 1);
15116                        {
15117                        setState(1804);
15118                        match(JAVADOC_INLINE_TAG_START);
15119                        setState(1881);
15120                        _errHandler.sync(this);
15121                        switch (_input.LA(1)) {
15122                        case CODE_LITERAL:
15123                                {
15124                                setState(1805);
15125                                match(CODE_LITERAL);
15126                                setState(1812);
15127                                _errHandler.sync(this);
15128                                _la = _input.LA(1);
15129                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15130                                        {
15131                                        setState(1810);
15132                                        _errHandler.sync(this);
15133                                        switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
15134                                        case 1:
15135                                                {
15136                                                setState(1806);
15137                                                match(WS);
15138                                                }
15139                                                break;
15140                                        case 2:
15141                                                {
15142                                                setState(1807);
15143                                                match(NEWLINE);
15144                                                }
15145                                                break;
15146                                        case 3:
15147                                                {
15148                                                setState(1808);
15149                                                match(LEADING_ASTERISK);
15150                                                }
15151                                                break;
15152                                        case 4:
15153                                                {
15154                                                setState(1809);
15155                                                text();
15156                                                }
15157                                                break;
15158                                        }
15159                                        }
15160                                        setState(1814);
15161                                        _errHandler.sync(this);
15162                                        _la = _input.LA(1);
15163                                }
15164                                }
15165                                break;
15166                        case DOC_ROOT_LITERAL:
15167                                {
15168                                setState(1815);
15169                                match(DOC_ROOT_LITERAL);
15170                                setState(1819);
15171                                _errHandler.sync(this);
15172                                _la = _input.LA(1);
15173                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15174                                        {
15175                                        {
15176                                        setState(1816);
15177                                        _la = _input.LA(1);
15178                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15179                                        _errHandler.recoverInline(this);
15180                                        }
15181                                        else {
15182                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15183                                                _errHandler.reportMatch(this);
15184                                                consume();
15185                                        }
15186                                        }
15187                                        }
15188                                        setState(1821);
15189                                        _errHandler.sync(this);
15190                                        _la = _input.LA(1);
15191                                }
15192                                }
15193                                break;
15194                        case INHERIT_DOC_LITERAL:
15195                                {
15196                                setState(1822);
15197                                match(INHERIT_DOC_LITERAL);
15198                                setState(1826);
15199                                _errHandler.sync(this);
15200                                _la = _input.LA(1);
15201                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15202                                        {
15203                                        {
15204                                        setState(1823);
15205                                        _la = _input.LA(1);
15206                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15207                                        _errHandler.recoverInline(this);
15208                                        }
15209                                        else {
15210                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15211                                                _errHandler.reportMatch(this);
15212                                                consume();
15213                                        }
15214                                        }
15215                                        }
15216                                        setState(1828);
15217                                        _errHandler.sync(this);
15218                                        _la = _input.LA(1);
15219                                }
15220                                }
15221                                break;
15222                        case LINK_LITERAL:
15223                                {
15224                                setState(1829);
15225                                match(LINK_LITERAL);
15226                                setState(1833);
15227                                _errHandler.sync(this);
15228                                _la = _input.LA(1);
15229                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15230                                        {
15231                                        {
15232                                        setState(1830);
15233                                        _la = _input.LA(1);
15234                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15235                                        _errHandler.recoverInline(this);
15236                                        }
15237                                        else {
15238                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15239                                                _errHandler.reportMatch(this);
15240                                                consume();
15241                                        }
15242                                        }
15243                                        }
15244                                        setState(1835);
15245                                        _errHandler.sync(this);
15246                                        _la = _input.LA(1);
15247                                }
15248                                setState(1836);
15249                                reference();
15250                                setState(1838);
15251                                _errHandler.sync(this);
15252                                switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
15253                                case 1:
15254                                        {
15255                                        setState(1837);
15256                                        description();
15257                                        }
15258                                        break;
15259                                }
15260                                }
15261                                break;
15262                        case LINKPLAIN_LITERAL:
15263                                {
15264                                setState(1840);
15265                                match(LINKPLAIN_LITERAL);
15266                                setState(1844);
15267                                _errHandler.sync(this);
15268                                _la = _input.LA(1);
15269                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15270                                        {
15271                                        {
15272                                        setState(1841);
15273                                        _la = _input.LA(1);
15274                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15275                                        _errHandler.recoverInline(this);
15276                                        }
15277                                        else {
15278                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15279                                                _errHandler.reportMatch(this);
15280                                                consume();
15281                                        }
15282                                        }
15283                                        }
15284                                        setState(1846);
15285                                        _errHandler.sync(this);
15286                                        _la = _input.LA(1);
15287                                }
15288                                setState(1847);
15289                                reference();
15290                                setState(1849);
15291                                _errHandler.sync(this);
15292                                switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
15293                                case 1:
15294                                        {
15295                                        setState(1848);
15296                                        description();
15297                                        }
15298                                        break;
15299                                }
15300                                }
15301                                break;
15302                        case LITERAL_LITERAL:
15303                                {
15304                                setState(1851);
15305                                match(LITERAL_LITERAL);
15306                                setState(1858);
15307                                _errHandler.sync(this);
15308                                _la = _input.LA(1);
15309                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15310                                        {
15311                                        setState(1856);
15312                                        _errHandler.sync(this);
15313                                        switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
15314                                        case 1:
15315                                                {
15316                                                setState(1852);
15317                                                match(WS);
15318                                                }
15319                                                break;
15320                                        case 2:
15321                                                {
15322                                                setState(1853);
15323                                                match(NEWLINE);
15324                                                }
15325                                                break;
15326                                        case 3:
15327                                                {
15328                                                setState(1854);
15329                                                match(LEADING_ASTERISK);
15330                                                }
15331                                                break;
15332                                        case 4:
15333                                                {
15334                                                setState(1855);
15335                                                text();
15336                                                }
15337                                                break;
15338                                        }
15339                                        }
15340                                        setState(1860);
15341                                        _errHandler.sync(this);
15342                                        _la = _input.LA(1);
15343                                }
15344                                }
15345                                break;
15346                        case VALUE_LITERAL:
15347                                {
15348                                setState(1861);
15349                                match(VALUE_LITERAL);
15350                                setState(1865);
15351                                _errHandler.sync(this);
15352                                _la = _input.LA(1);
15353                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15354                                        {
15355                                        {
15356                                        setState(1862);
15357                                        _la = _input.LA(1);
15358                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15359                                        _errHandler.recoverInline(this);
15360                                        }
15361                                        else {
15362                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15363                                                _errHandler.reportMatch(this);
15364                                                consume();
15365                                        }
15366                                        }
15367                                        }
15368                                        setState(1867);
15369                                        _errHandler.sync(this);
15370                                        _la = _input.LA(1);
15371                                }
15372                                setState(1869);
15373                                _errHandler.sync(this);
15374                                _la = _input.LA(1);
15375                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) {
15376                                        {
15377                                        setState(1868);
15378                                        reference();
15379                                        }
15380                                }
15381
15382                                }
15383                                break;
15384                        case CUSTOM_NAME:
15385                                {
15386                                setState(1871);
15387                                match(CUSTOM_NAME);
15388                                setState(1875);
15389                                _errHandler.sync(this);
15390                                _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15391                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
15392                                        if ( _alt==1 ) {
15393                                                {
15394                                                {
15395                                                setState(1872);
15396                                                _la = _input.LA(1);
15397                                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15398                                                _errHandler.recoverInline(this);
15399                                                }
15400                                                else {
15401                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15402                                                        _errHandler.reportMatch(this);
15403                                                        consume();
15404                                                }
15405                                                }
15406                                                } 
15407                                        }
15408                                        setState(1877);
15409                                        _errHandler.sync(this);
15410                                        _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15411                                }
15412                                setState(1879);
15413                                _errHandler.sync(this);
15414                                switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
15415                                case 1:
15416                                        {
15417                                        setState(1878);
15418                                        description();
15419                                        }
15420                                        break;
15421                                }
15422                                }
15423                                break;
15424                        default:
15425                                throw new NoViableAltException(this);
15426                        }
15427                        setState(1883);
15428                        match(JAVADOC_INLINE_TAG_END);
15429                        }
15430                }
15431                catch (RecognitionException re) {
15432                        _localctx.exception = re;
15433                        _errHandler.reportError(this, re);
15434                        _errHandler.recover(this, re);
15435                }
15436                finally {
15437                        exitRule();
15438                }
15439                return _localctx;
15440        }
15441
15442        public static class HtmlCommentContext extends ParserRuleContext {
15443                public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); }
15444                public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); }
15445                public List<TextContext> text() {
15446                        return getRuleContexts(TextContext.class);
15447                }
15448                public TextContext text(int i) {
15449                        return getRuleContext(TextContext.class,i);
15450                }
15451                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15452                public TerminalNode NEWLINE(int i) {
15453                        return getToken(JavadocParser.NEWLINE, i);
15454                }
15455                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15456                public TerminalNode LEADING_ASTERISK(int i) {
15457                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15458                }
15459                public HtmlCommentContext(ParserRuleContext parent, int invokingState) {
15460                        super(parent, invokingState);
15461                }
15462                @Override public int getRuleIndex() { return RULE_htmlComment; }
15463                @Override
15464                public void enterRule(ParseTreeListener listener) {
15465                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this);
15466                }
15467                @Override
15468                public void exitRule(ParseTreeListener listener) {
15469                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this);
15470                }
15471                @Override
15472                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15473                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this);
15474                        else return visitor.visitChildren(this);
15475                }
15476        }
15477
15478        public final HtmlCommentContext htmlComment() throws RecognitionException {
15479                HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState());
15480                enterRule(_localctx, 146, RULE_htmlComment);
15481                int _la;
15482                try {
15483                        enterOuterAlt(_localctx, 1);
15484                        {
15485                        setState(1885);
15486                        match(HTML_COMMENT_START);
15487                        setState(1891);
15488                        _errHandler.sync(this);
15489                        _la = _input.LA(1);
15490                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15491                                {
15492                                setState(1889);
15493                                _errHandler.sync(this);
15494                                switch (_input.LA(1)) {
15495                                case WS:
15496                                case CHAR:
15497                                        {
15498                                        setState(1886);
15499                                        text();
15500                                        }
15501                                        break;
15502                                case NEWLINE:
15503                                        {
15504                                        setState(1887);
15505                                        match(NEWLINE);
15506                                        }
15507                                        break;
15508                                case LEADING_ASTERISK:
15509                                        {
15510                                        setState(1888);
15511                                        match(LEADING_ASTERISK);
15512                                        }
15513                                        break;
15514                                default:
15515                                        throw new NoViableAltException(this);
15516                                }
15517                                }
15518                                setState(1893);
15519                                _errHandler.sync(this);
15520                                _la = _input.LA(1);
15521                        }
15522                        setState(1894);
15523                        match(HTML_COMMENT_END);
15524                        }
15525                }
15526                catch (RecognitionException re) {
15527                        _localctx.exception = re;
15528                        _errHandler.reportError(this, re);
15529                        _errHandler.recover(this, re);
15530                }
15531                finally {
15532                        exitRule();
15533                }
15534                return _localctx;
15535        }
15536
15537        public static class TextContext extends ParserRuleContext {
15538                public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); }
15539                public TerminalNode CHAR(int i) {
15540                        return getToken(JavadocParser.CHAR, i);
15541                }
15542                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15543                public TerminalNode WS(int i) {
15544                        return getToken(JavadocParser.WS, i);
15545                }
15546                public TextContext(ParserRuleContext parent, int invokingState) {
15547                        super(parent, invokingState);
15548                }
15549                @Override public int getRuleIndex() { return RULE_text; }
15550                @Override
15551                public void enterRule(ParseTreeListener listener) {
15552                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this);
15553                }
15554                @Override
15555                public void exitRule(ParseTreeListener listener) {
15556                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this);
15557                }
15558                @Override
15559                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15560                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this);
15561                        else return visitor.visitChildren(this);
15562                }
15563        }
15564
15565        public final TextContext text() throws RecognitionException {
15566                TextContext _localctx = new TextContext(_ctx, getState());
15567                enterRule(_localctx, 148, RULE_text);
15568                int _la;
15569                try {
15570                        int _alt;
15571                        enterOuterAlt(_localctx, 1);
15572                        {
15573                        setState(1898); 
15574                        _errHandler.sync(this);
15575                        _alt = 1;
15576                        do {
15577                                switch (_alt) {
15578                                case 1:
15579                                        {
15580                                        {
15581                                        setState(1896);
15582                                        _la = _input.LA(1);
15583                                        if ( !(_la==WS || _la==CHAR) ) {
15584                                        _errHandler.recoverInline(this);
15585                                        }
15586                                        else {
15587                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15588                                                _errHandler.reportMatch(this);
15589                                                consume();
15590                                        }
15591
15592                                          _la = _input.LA(1);
15593                                          if ((_la != WS) && (_la != CHAR)) return _localctx;
15594                                          else if (_alt == 1) continue;
15595                                         
15596                                        }
15597                                        }
15598                                        break;
15599                                default:
15600                                        throw new NoViableAltException(this);
15601                                }
15602                                setState(1900); 
15603                                _errHandler.sync(this);
15604                                _alt = getInterpreter().adaptivePredict(_input,194,_ctx);
15605                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15606                        }
15607                }
15608                catch (RecognitionException re) {
15609                        _localctx.exception = re;
15610                        _errHandler.reportError(this, re);
15611                        _errHandler.recover(this, re);
15612                }
15613                finally {
15614                        exitRule();
15615                }
15616                return _localctx;
15617        }
15618
15619        public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
15620                switch (ruleIndex) {
15621                case 0:
15622                        return javadoc_sempred((JavadocContext)_localctx, predIndex);
15623                case 5:
15624                        return htmlTag_sempred((HtmlTagContext)_localctx, predIndex);
15625                case 8:
15626                        return paragraph_sempred((ParagraphContext)_localctx, predIndex);
15627                case 11:
15628                        return li_sempred((LiContext)_localctx, predIndex);
15629                case 14:
15630                        return tr_sempred((TrContext)_localctx, predIndex);
15631                case 17:
15632                        return td_sempred((TdContext)_localctx, predIndex);
15633                case 20:
15634                        return th_sempred((ThContext)_localctx, predIndex);
15635                case 23:
15636                        return body_sempred((BodyContext)_localctx, predIndex);
15637                case 26:
15638                        return colgroup_sempred((ColgroupContext)_localctx, predIndex);
15639                case 29:
15640                        return dd_sempred((DdContext)_localctx, predIndex);
15641                case 32:
15642                        return dt_sempred((DtContext)_localctx, predIndex);
15643                case 35:
15644                        return head_sempred((HeadContext)_localctx, predIndex);
15645                case 38:
15646                        return html_sempred((HtmlContext)_localctx, predIndex);
15647                case 41:
15648                        return option_sempred((OptionContext)_localctx, predIndex);
15649                case 44:
15650                        return tbody_sempred((TbodyContext)_localctx, predIndex);
15651                case 47:
15652                        return tfoot_sempred((TfootContext)_localctx, predIndex);
15653                case 50:
15654                        return thead_sempred((TheadContext)_localctx, predIndex);
15655                case 68:
15656                        return description_sempred((DescriptionContext)_localctx, predIndex);
15657                }
15658                return true;
15659        }
15660        private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) {
15661                switch (predIndex) {
15662                case 0:
15663                        return !isNextJavadocTag();
15664                }
15665                return true;
15666        }
15667        private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) {
15668                switch (predIndex) {
15669                case 1:
15670                        return !isNextJavadocTag();
15671                case 2:
15672                        return !isNextJavadocTag();
15673                }
15674                return true;
15675        }
15676        private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) {
15677                switch (predIndex) {
15678                case 3:
15679                        return !isNextJavadocTag();
15680                }
15681                return true;
15682        }
15683        private boolean li_sempred(LiContext _localctx, int predIndex) {
15684                switch (predIndex) {
15685                case 4:
15686                        return !isNextJavadocTag();
15687                }
15688                return true;
15689        }
15690        private boolean tr_sempred(TrContext _localctx, int predIndex) {
15691                switch (predIndex) {
15692                case 5:
15693                        return !isNextJavadocTag();
15694                }
15695                return true;
15696        }
15697        private boolean td_sempred(TdContext _localctx, int predIndex) {
15698                switch (predIndex) {
15699                case 6:
15700                        return !isNextJavadocTag();
15701                }
15702                return true;
15703        }
15704        private boolean th_sempred(ThContext _localctx, int predIndex) {
15705                switch (predIndex) {
15706                case 7:
15707                        return !isNextJavadocTag();
15708                }
15709                return true;
15710        }
15711        private boolean body_sempred(BodyContext _localctx, int predIndex) {
15712                switch (predIndex) {
15713                case 8:
15714                        return !isNextJavadocTag();
15715                }
15716                return true;
15717        }
15718        private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) {
15719                switch (predIndex) {
15720                case 9:
15721                        return !isNextJavadocTag();
15722                }
15723                return true;
15724        }
15725        private boolean dd_sempred(DdContext _localctx, int predIndex) {
15726                switch (predIndex) {
15727                case 10:
15728                        return !isNextJavadocTag();
15729                }
15730                return true;
15731        }
15732        private boolean dt_sempred(DtContext _localctx, int predIndex) {
15733                switch (predIndex) {
15734                case 11:
15735                        return !isNextJavadocTag();
15736                }
15737                return true;
15738        }
15739        private boolean head_sempred(HeadContext _localctx, int predIndex) {
15740                switch (predIndex) {
15741                case 12:
15742                        return !isNextJavadocTag();
15743                }
15744                return true;
15745        }
15746        private boolean html_sempred(HtmlContext _localctx, int predIndex) {
15747                switch (predIndex) {
15748                case 13:
15749                        return !isNextJavadocTag();
15750                }
15751                return true;
15752        }
15753        private boolean option_sempred(OptionContext _localctx, int predIndex) {
15754                switch (predIndex) {
15755                case 14:
15756                        return !isNextJavadocTag();
15757                }
15758                return true;
15759        }
15760        private boolean tbody_sempred(TbodyContext _localctx, int predIndex) {
15761                switch (predIndex) {
15762                case 15:
15763                        return !isNextJavadocTag();
15764                }
15765                return true;
15766        }
15767        private boolean tfoot_sempred(TfootContext _localctx, int predIndex) {
15768                switch (predIndex) {
15769                case 16:
15770                        return !isNextJavadocTag();
15771                }
15772                return true;
15773        }
15774        private boolean thead_sempred(TheadContext _localctx, int predIndex) {
15775                switch (predIndex) {
15776                case 17:
15777                        return !isNextJavadocTag();
15778                }
15779                return true;
15780        }
15781        private boolean description_sempred(DescriptionContext _localctx, int predIndex) {
15782                switch (predIndex) {
15783                case 18:
15784                        return !isNextJavadocTag();
15785                }
15786                return true;
15787        }
15788
15789        public static final String _serializedATN =
15790                "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3]\u0771\4\2\t\2\4"+
15791                "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
15792                "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
15793                "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
15794                "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
15795                "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
15796                ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
15797                "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
15798                "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
15799                "\tI\4J\tJ\4K\tK\4L\tL\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2\u00a1\n\2\f"+
15800                "\2\16\2\u00a4\13\2\3\2\5\2\u00a7\n\2\3\2\7\2\u00aa\n\2\f\2\16\2\u00ad"+
15801                "\13\2\3\2\7\2\u00b0\n\2\f\2\16\2\u00b3\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3"+
15802                "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
15803                "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
15804                "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00e6\n\3\3\4\3\4\3\4\3\4\3\4\3\4\7"+
15805                "\4\u00ee\n\4\f\4\16\4\u00f1\13\4\3\4\3\4\3\5\3\5\3\5\3\5\7\5\u00f9\n\5"+
15806                "\f\5\16\5\u00fc\13\5\3\5\3\5\3\6\3\6\7\6\u0102\n\6\f\6\16\6\u0105\13\6"+
15807                "\3\6\3\6\7\6\u0109\n\6\f\6\16\6\u010c\13\6\3\6\3\6\3\6\5\6\u0111\n\6\3"+
15808                "\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u011c\n\7\f\7\16\7\u011f\13\7\3"+
15809                "\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u012c\n\7\f\7\16\7\u012f"+
15810                "\13\7\3\7\3\7\5\7\u0133\n\7\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u013b\n\b\f\b"+
15811                "\16\b\u013e\13\b\3\b\3\b\3\t\3\t\3\t\3\t\7\t\u0146\n\t\f\t\16\t\u0149"+
15812                "\13\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n"+
15813                "\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3"+
15814                "\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u0173\n\n\f\n\16\n\u0176\13\n\3\n\3\n\3"+
15815                "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+
15816                "\13\3\13\3\f\3\f\3\f\3\f\7\f\u018b\n\f\f\f\16\f\u018e\13\f\3\f\3\f\3\r"+
15817                "\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3"+
15818                "\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r"+
15819                "\3\r\3\r\7\r\u01b8\n\r\f\r\16\r\u01bb\13\r\3\r\3\r\3\16\3\16\3\16\3\16"+
15820                "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+
15821                "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+
15822                "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
15823                "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
15824                "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u01fd\n\20\f\20\16\20\u0200"+
15825                "\13\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u020a\n\21\f\21\16"+
15826                "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+
15827                "\22\u0218\13\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
15828                "\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
15829                "\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
15830                "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+
15831                "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+
15832                "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+
15833                "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+
15834                "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+
15835                "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\7\26\u0287\n\26\f\26\16"+
15836                "\26\u028a\13\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u0294\n\27"+
15837                "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+
15838                "\f\30\16\30\u02a2\13\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+
15839                "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+
15840                "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+
15841                "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+
15842                "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+
15843                "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+
15844                "\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+
15845                "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+
15846                "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u0311\n\34"+
15847                "\f\34\16\34\u0314\13\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\7\35\u031e"+
15848                "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+
15849                "\n\36\f\36\16\36\u032c\13\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3"+
15850                "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+
15851                "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+
15852                "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+
15853                " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+
15854                "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
15855                "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
15856                "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+
15857                "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+
15858                "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15859                "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15860                "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+
15861                "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+
15862                "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15863                "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15864                "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+
15865                ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+
15866                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+
15867                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+
15868                "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+
15869                "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15870                "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15871                "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+
15872                "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+
15873                "\60\u04ca\13\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+
15874                "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+
15875                "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+
15876                "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+
15877                "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+
15878                "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+
15879                "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+
15880                "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+
15881                "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u0539\n\64\f\64\16"+
15882                "\64\u053c\13\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65"+
15883                "\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u054f\n\65\3\66\3\66\3\66\3\66\3\66"+
15884                "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+
15885                "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+
15886                "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+
15887                "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+
15888                "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+
15889                "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+
15890                "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+
15891                "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+
15892                "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+
15893                "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+
15894                "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+
15895                "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+
15896                "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+
15897                "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+
15898                "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+
15899                "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+
15900                "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+
15901                "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+
15902                "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+
15903                "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+
15904                "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+
15905                "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+
15906                "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+
15907                "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+
15908                "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+
15909                "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+
15910                "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+
15911                "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+
15912                "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+
15913                "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+
15914                "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+
15915                "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+
15916                "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+
15917                "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+
15918                "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+
15919                "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+
15920                "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+
15921                "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+
15922                "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+
15923                "\6\b\b\4\2=KYY\3\29:\3\2LX\4\2\37\37!!\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b"+
15924                "\3\2\30\31\4\2\6\6\32\32\2\u0a88\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7"+
15925                "\3\2\2\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2"+
15926                "\2\2\20\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2"+
15927                "\2\30\u0191\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2"+
15928                " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+
15929                "\2\2\2*\u0260\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62"+
15930                "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+
15931                "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+
15932                "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+
15933                "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+
15934                "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+
15935                "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+
15936                "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+
15937                "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+
15938                "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+
15939                "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+
15940                "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+
15941                "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+
15942                "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+
15943                "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+
15944                "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+
15945                "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+
15946                "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
15947                "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+
15948                "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+
15949                "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+
15950                "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+
15951                "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
15952                "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+
15953                "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+
15954                "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+
15955                "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+
15956                "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+
15957                "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+
15958                "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+
15959                "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+
15960                "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+
15961                "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+
15962                "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+
15963                "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+
15964                "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+
15965                "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+
15966                "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+
15967                "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+
15968                "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+
15969                "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+
15970                "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+
15971                "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+
15972                "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+
15973                "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+
15974                "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+
15975                "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+
15976                "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+
15977                "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+
15978                "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+
15979                "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+
15980                "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+
15981                "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+
15982                "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+
15983                "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+
15984                "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+
15985                "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+
15986                "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
15987                "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+
15988                "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+
15989                "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+
15990                "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+
15991                "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+
15992                "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+
15993                "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+
15994                "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+
15995                "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+
15996                "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+
15997                "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+
15998                "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+
15999                "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
16000                "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+
16001                "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+
16002                "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+
16003                "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+
16004                "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+
16005                "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+
16006                "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+
16007                "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+
16008                "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+
16009                "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+
16010                "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+
16011                "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
16012                "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+
16013                "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+
16014                "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+
16015                "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+
16016                "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+
16017                "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+
16018                "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+
16019                "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+
16020                "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+
16021                "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+
16022                "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+
16023                "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+
16024                "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+
16025                "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+
16026                "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+
16027                "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+
16028                "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+
16029                "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+
16030                "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+
16031                "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+
16032                "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+
16033                "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+
16034                "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
16035                "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+
16036                "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+
16037                "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+
16038                "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+
16039                "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+
16040                "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+
16041                "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+
16042                "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
16043                "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+
16044                "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+
16045                "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+
16046                "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+
16047                "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+
16048                "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+
16049                "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+
16050                "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+
16051                "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+
16052                "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+
16053                "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+
16054                "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+
16055                "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+
16056                "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+
16057                "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+
16058                "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+
16059                "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+
16060                "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+
16061                "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+
16062                "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+
16063                "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+
16064                "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+
16065                "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+
16066                "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+
16067                "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+
16068                "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+
16069                "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+
16070                "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+
16071                "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+
16072                "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+
16073                "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+
16074                "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+
16075                "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+
16076                "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
16077                "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
16078                "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+
16079                "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+
16080                "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+
16081                "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+
16082                "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+
16083                "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+
16084                "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+
16085                "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+
16086                "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+
16087                "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+
16088                "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+
16089                "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+
16090                "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+
16091                "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+
16092                "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+
16093                "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+
16094                "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+
16095                "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+
16096                "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+
16097                "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+
16098                "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+
16099                "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+
16100                "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+
16101                "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+
16102                "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+
16103                "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+
16104                "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+
16105                "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+
16106                "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+
16107                "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+
16108                "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+
16109                "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+
16110                "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+
16111                "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+
16112                "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+
16113                "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+
16114                "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+
16115                "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+
16116                "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+
16117                "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+
16118                "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+
16119                "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+
16120                "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+
16121                "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+
16122                "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+
16123                "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+
16124                "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+
16125                "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+
16126                "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+
16127                "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+
16128                "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+
16129                "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+
16130                "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+
16131                "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+
16132                "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+
16133                "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+
16134                "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+
16135                "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
16136                "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+
16137                "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+
16138                "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+
16139                "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+
16140                "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+
16141                "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+
16142                "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+
16143                "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+
16144                "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+
16145                "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+
16146                "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+
16147                "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+
16148                "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+
16149                "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+
16150                "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+
16151                "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+
16152                "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+
16153                "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+
16154                "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+
16155                "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+
16156                "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+
16157                "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+
16158                "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+
16159                "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+
16160                "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+
16161                "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
16162                "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+
16163                "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+
16164                "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+
16165                "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+
16166                "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+
16167                "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+
16168                "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+
16169                "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+
16170                "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+
16171                "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+
16172                "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+
16173                "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+
16174                "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+
16175                "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+
16176                "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+
16177                "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+
16178                "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+
16179                ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+
16180                "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+
16181                "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+
16182                "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+
16183                "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+
16184                "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+
16185                "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+
16186                "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+
16187                "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+
16188                "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+
16189                "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+
16190                "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+
16191                "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+
16192                "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+
16193                "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+
16194                "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+
16195                "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+
16196                "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+
16197                "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+
16198                "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+
16199                "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+
16200                "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+
16201                "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+
16202                "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+
16203                "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+
16204                "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+
16205                "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+
16206                "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+
16207                "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+
16208                "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+
16209                "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+
16210                "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+
16211                "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+
16212                "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+
16213                "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+
16214                "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+
16215                "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+
16216                "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+
16217                "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+
16218                "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+
16219                "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+
16220                "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+
16221                "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+
16222                "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+
16223                "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
16224                "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+
16225                "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+
16226                "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+
16227                "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+
16228                "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+
16229                "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+
16230                "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+
16231                "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+
16232                "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+
16233                ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+
16234                "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+
16235                "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+
16236                "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+
16237                "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+
16238                "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+
16239                "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+
16240                "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+
16241                "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+
16242                "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+
16243                "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+
16244                "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+
16245                "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+
16246                "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+
16247                "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+
16248                "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+
16249                "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+
16250                "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+
16251                "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+
16252                "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+
16253                "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+
16254                "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+
16255                "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+
16256                "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+
16257                "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+
16258                "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+
16259                "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
16260                "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+
16261                "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+
16262                "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+
16263                "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+
16264                "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+
16265                "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+
16266                "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+
16267                "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+
16268                "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+
16269                "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+
16270                "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+
16271                "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+
16272                "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+
16273                "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+
16274                "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+
16275                "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+
16276                "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+
16277                "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+
16278                "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+
16279                "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+
16280                "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+
16281                "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+
16282                "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+
16283                "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+
16284                "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+
16285                "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+
16286                "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+
16287                "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+
16288                "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+
16289                "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+
16290                "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+
16291                "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+
16292                "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+
16293                "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+
16294                "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+
16295                "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+
16296                "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+
16297                "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+
16298                "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+
16299                "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+
16300                "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+
16301                "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+
16302                "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+
16303                "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+
16304                "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+
16305                "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+
16306                "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+
16307                "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+
16308                "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+
16309                "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+
16310                "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+
16311                "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+
16312                "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+
16313                "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+
16314                "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+
16315                "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+
16316                "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+
16317                "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+
16318                "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+
16319                "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+
16320                "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
16321                "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+
16322                "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+
16323                "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+
16324                "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+
16325                "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+
16326                "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+
16327                "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+
16328                "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+
16329                "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+
16330                "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+
16331                "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+
16332                "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+
16333                "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+
16334                "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+
16335                "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+
16336                "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+
16337                "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+
16338                "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+
16339                "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+
16340                "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+
16341                "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+
16342                "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+
16343                "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+
16344                "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+
16345                "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+
16346                "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+
16347                "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+
16348                "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+
16349                "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+
16350                "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+
16351                "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+
16352                "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+
16353                "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+
16354                "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+
16355                "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+
16356                "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+
16357                "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+
16358                "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+
16359                "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+
16360                "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+
16361                "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+
16362                "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+
16363                "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+
16364                "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+
16365                "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+
16366                "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+
16367                "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+
16368                "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+
16369                "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+
16370                "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+
16371                "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+
16372                "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+
16373                "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+
16374                "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+
16375                "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+
16376                "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+
16377                "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+
16378                "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+
16379                "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+
16380                "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+
16381                "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+
16382                "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+
16383                "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+
16384                "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+
16385                "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+
16386                "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+
16387                "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+
16388                "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+
16389                "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+
16390                "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+
16391                "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+
16392                "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+
16393                "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+
16394                "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+
16395                "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+
16396                "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+
16397                "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+
16398                "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+
16399                "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+
16400                "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+
16401                "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+
16402                "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+
16403                "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+
16404                "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+
16405                "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+
16406                "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+
16407                "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+
16408                "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+
16409                "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+
16410                "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+
16411                "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+
16412                "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+
16413                "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+
16414                "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+
16415                "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+
16416                "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+
16417                "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+
16418                "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+
16419                "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+
16420                "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+
16421                "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+
16422                "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+
16423                "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+
16424                "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+
16425                "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+
16426                "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+
16427                "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+
16428                "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+
16429                "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+
16430                "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+
16431                "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+
16432                "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+
16433                "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+
16434                "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+
16435                "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+
16436                "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+
16437                "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+
16438                "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+
16439                "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+
16440                "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+
16441                "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+
16442                "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+
16443                "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+
16444                "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+
16445                "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+
16446                "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+
16447                "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+
16448                "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+
16449                "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+
16450                "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+
16451                "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+
16452                "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+
16453                "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+
16454                "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+
16455                "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+
16456                "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+
16457                "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+
16458                "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+
16459                "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+
16460                "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+
16461                "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+
16462                "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+
16463                "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+
16464                "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+
16465                "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+
16466                "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+
16467                "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+
16468                "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+
16469                "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+
16470                "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+
16471                "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
16472                "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+
16473                "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+
16474                "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+
16475                "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+
16476                "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+
16477                "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+
16478                "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+
16479                "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+
16480                "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+
16481                "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+
16482                "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+
16483                "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+
16484                "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+
16485                "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+
16486                "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+
16487                "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+
16488                "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+
16489                "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+
16490                "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+
16491                "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+
16492                "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+
16493                "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+
16494                "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+
16495                "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+
16496                "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+
16497                "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+
16498                "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+
16499                "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+
16500                "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+
16501                "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+
16502                "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+
16503                "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+
16504                "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+
16505                "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+
16506                "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+
16507                "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+
16508                "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+
16509                "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+
16510                "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+
16511                "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+
16512                "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+
16513                "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+
16514                "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+
16515                "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+
16516                "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+
16517                "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+
16518                "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+
16519                "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+
16520                "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+
16521                "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+
16522                "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+
16523                "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+
16524                "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+
16525                "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+
16526                "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+
16527                "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+
16528                "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+
16529                "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+
16530                "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+
16531                "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+
16532                "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+
16533                "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+
16534                "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+
16535                "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+
16536                "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+
16537                "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+
16538                "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+
16539                "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+
16540                "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
16541                "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+
16542                "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+
16543                "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+
16544                "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+
16545                "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+
16546                "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+
16547                "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+
16548                "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+
16549                "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+
16550                "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+
16551                "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+
16552                "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+
16553                "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+
16554                "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+
16555                "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+
16556                "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+
16557                "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+
16558                "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+
16559                "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+
16560                "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+
16561                "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+
16562                "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+
16563                "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+
16564                "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+
16565                "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+
16566                "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+
16567                "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+
16568                "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+
16569                "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+
16570                "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+
16571                "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+
16572                "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+
16573                "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+
16574                "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+
16575                "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+
16576                "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+
16577                "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+
16578                "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+
16579                "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+
16580                "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+
16581                "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+
16582                "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+
16583                "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+
16584                "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+
16585                "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+
16586                "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+
16587                "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+
16588                "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+
16589                "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+
16590                "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+
16591                "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+
16592                "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+
16593                "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+
16594                "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+
16595                "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+
16596                "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+
16597                "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+
16598                "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+
16599                "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+
16600                "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+
16601                "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+
16602                "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+
16603                "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
16604                "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+
16605                "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+
16606                "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+
16607                "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+
16608                "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+
16609                "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+
16610                "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+
16611                "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+
16612                "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+
16613                "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+
16614                "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+
16615                "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+
16616                "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+
16617                "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+
16618                "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+
16619                "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+
16620                "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+
16621                "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+
16622                "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+
16623                "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+
16624                "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+
16625                "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+
16626                "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+
16627                "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+
16628                "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+
16629                "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+
16630                "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+
16631                "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+
16632                "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+
16633                "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+
16634                "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+
16635                "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+
16636                "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+
16637                "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+
16638                "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+
16639                "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+
16640                "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+
16641                "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+
16642                "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+
16643                "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+
16644                "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+
16645                "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+
16646                "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+
16647                "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+
16648                "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+
16649                "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+
16650                "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+
16651                "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+
16652                "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+
16653                "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+
16654                "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+
16655                "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+
16656                "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+
16657                "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+
16658                "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+
16659                "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+
16660                "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+
16661                "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+
16662                "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+
16663                "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+
16664                "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+
16665                "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+
16666                "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
16667                "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+
16668                "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+
16669                "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+
16670                "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+
16671                "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+
16672                "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+
16673                "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+
16674                "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+
16675                "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+
16676                "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+
16677                "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+
16678                "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+
16679                "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+
16680                "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+
16681                "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+
16682                "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+
16683                "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+
16684                "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+
16685                "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+
16686                "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+
16687                "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+
16688                "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+
16689                "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+
16690                "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+
16691                "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+
16692                "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+
16693                "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+
16694                "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+
16695                "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+
16696                "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e";
16697        public static final ATN _ATN =
16698                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
16699        static {
16700                _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
16701                for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
16702                        _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
16703                }
16704        }
16705}