001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.7
002package com.puppycrawl.tools.checkstyle.grammars.javadoc;
003import org.antlr.v4.runtime.atn.*;
004import org.antlr.v4.runtime.dfa.DFA;
005import org.antlr.v4.runtime.*;
006import org.antlr.v4.runtime.misc.*;
007import org.antlr.v4.runtime.tree.*;
008import java.util.List;
009import java.util.Iterator;
010import java.util.ArrayList;
011
012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
013public class JavadocParser extends Parser {
014        static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
015
016        protected static final DFA[] _decisionToDFA;
017        protected static final PredictionContextCache _sharedContextCache =
018                new PredictionContextCache();
019        public static final int
020                LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, 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        public static final String[] ruleNames = {
063                "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 
064                "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 
065                "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 
066                "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 
067                "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 
068                "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 
069                "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 
070                "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 
071                "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 
072                "singletonTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", 
073                "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 
074                "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 
075                "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text"
076        };
077
078        private static final String[] _LITERAL_NAMES = {
079                null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 
080                null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 
081                null, "'@version'", null, null, null, "'include'", "'exclude'", null, 
082                null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 
083                "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 
084                "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 
085                "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 
086                null, null, null, null, null, null, null, null, null, null, null, null, 
087                null, null, null, null, null, null, null, null, null, null, "'-->'"
088        };
089        private static final String[] _SYMBOLIC_NAMES = {
090                null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 
091                "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 
092                "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 
093                "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 
094                "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 
095                "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", 
096                "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 
097                "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 
098                "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 
099                "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 
100                "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "SLASH", "EQUALS", 
101                "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 
102                "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 
103                "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 
104                "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 
105                "BASE_HTML_TAG_NAME", "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 
106                "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 
107                "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 
108                "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END"
109        };
110        public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
111
112        /**
113         * @deprecated Use {@link #VOCABULARY} instead.
114         */
115        @Deprecated
116        public static final String[] tokenNames;
117        static {
118                tokenNames = new String[_SYMBOLIC_NAMES.length];
119                for (int i = 0; i < tokenNames.length; i++) {
120                        tokenNames[i] = VOCABULARY.getLiteralName(i);
121                        if (tokenNames[i] == null) {
122                                tokenNames[i] = VOCABULARY.getSymbolicName(i);
123                        }
124
125                        if (tokenNames[i] == null) {
126                                tokenNames[i] = "<INVALID>";
127                        }
128                }
129        }
130
131        @Override
132        @Deprecated
133        public String[] getTokenNames() {
134                return tokenNames;
135        }
136
137        @Override
138
139        public Vocabulary getVocabulary() {
140                return VOCABULARY;
141        }
142
143        @Override
144        public String getGrammarFileName() { return "JavadocParser.g4"; }
145
146        @Override
147        public String[] getRuleNames() { return ruleNames; }
148
149        @Override
150        public String getSerializedATN() { return _serializedATN; }
151
152        @Override
153        public ATN getATN() { return _ATN; }
154
155
156            boolean isNextJavadocTag() {
157                int token1 = _input.LA(2);
158                int token2 = _input.LA(3);
159                return isJavadocTag(token1)
160                    || (token1 == WS && isJavadocTag(token2));
161            }
162
163            boolean isJavadocTag(int type) {
164                switch(type) {
165                    case AUTHOR_LITERAL:
166                    case DEPRECATED_LITERAL:
167                    case EXCEPTION_LITERAL:
168                    case PARAM_LITERAL:
169                    case RETURN_LITERAL:
170                    case SEE_LITERAL:
171                    case SERIAL_LITERAL:
172                    case SERIAL_FIELD_LITERAL:
173                    case SERIAL_DATA_LITERAL:
174                    case SINCE_LITERAL:
175                    case THROWS_LITERAL:
176                    case VERSION_LITERAL:
177                    case CUSTOM_NAME:
178                        return true;
179                    default:
180                        return false;
181                }
182            }
183
184              boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) {
185                    String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
186                    String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
187                    System.out.println(openTag + " - " + closeTag);
188                    return openTag.equals(closeTag);
189              }
190
191        public JavadocParser(TokenStream input) {
192                super(input);
193                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
194        }
195        public static class JavadocContext extends ParserRuleContext {
196                public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
197                public List<HtmlElementContext> htmlElement() {
198                        return getRuleContexts(HtmlElementContext.class);
199                }
200                public HtmlElementContext htmlElement(int i) {
201                        return getRuleContext(HtmlElementContext.class,i);
202                }
203                public List<HtmlCommentContext> htmlComment() {
204                        return getRuleContexts(HtmlCommentContext.class);
205                }
206                public HtmlCommentContext htmlComment(int i) {
207                        return getRuleContext(HtmlCommentContext.class,i);
208                }
209                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
210                public TerminalNode CDATA(int i) {
211                        return getToken(JavadocParser.CDATA, i);
212                }
213                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
214                public TerminalNode NEWLINE(int i) {
215                        return getToken(JavadocParser.NEWLINE, i);
216                }
217                public List<TextContext> text() {
218                        return getRuleContexts(TextContext.class);
219                }
220                public TextContext text(int i) {
221                        return getRuleContext(TextContext.class,i);
222                }
223                public List<JavadocInlineTagContext> javadocInlineTag() {
224                        return getRuleContexts(JavadocInlineTagContext.class);
225                }
226                public JavadocInlineTagContext javadocInlineTag(int i) {
227                        return getRuleContext(JavadocInlineTagContext.class,i);
228                }
229                public List<JavadocTagContext> javadocTag() {
230                        return getRuleContexts(JavadocTagContext.class);
231                }
232                public JavadocTagContext javadocTag(int i) {
233                        return getRuleContext(JavadocTagContext.class,i);
234                }
235                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
236                public TerminalNode LEADING_ASTERISK(int i) {
237                        return getToken(JavadocParser.LEADING_ASTERISK, i);
238                }
239                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
240                public TerminalNode WS(int i) {
241                        return getToken(JavadocParser.WS, i);
242                }
243                public JavadocContext(ParserRuleContext parent, int invokingState) {
244                        super(parent, invokingState);
245                }
246                @Override public int getRuleIndex() { return RULE_javadoc; }
247                @Override
248                public void enterRule(ParseTreeListener listener) {
249                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this);
250                }
251                @Override
252                public void exitRule(ParseTreeListener listener) {
253                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this);
254                }
255                @Override
256                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
257                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this);
258                        else return visitor.visitChildren(this);
259                }
260        }
261
262        public final JavadocContext javadoc() throws RecognitionException {
263                JavadocContext _localctx = new JavadocContext(_ctx, getState());
264                enterRule(_localctx, 0, RULE_javadoc);
265                int _la;
266                try {
267                        int _alt;
268                        enterOuterAlt(_localctx, 1);
269                        {
270                        setState(160);
271                        _errHandler.sync(this);
272                        _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
273                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
274                                if ( _alt==1 ) {
275                                        {
276                                        setState(158);
277                                        _errHandler.sync(this);
278                                        switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
279                                        case 1:
280                                                {
281                                                setState(150);
282                                                htmlElement();
283                                                }
284                                                break;
285                                        case 2:
286                                                {
287                                                {
288                                                setState(151);
289                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
290                                                setState(152);
291                                                match(LEADING_ASTERISK);
292                                                }
293                                                }
294                                                break;
295                                        case 3:
296                                                {
297                                                setState(153);
298                                                htmlComment();
299                                                }
300                                                break;
301                                        case 4:
302                                                {
303                                                setState(154);
304                                                match(CDATA);
305                                                }
306                                                break;
307                                        case 5:
308                                                {
309                                                setState(155);
310                                                match(NEWLINE);
311                                                }
312                                                break;
313                                        case 6:
314                                                {
315                                                setState(156);
316                                                text();
317                                                }
318                                                break;
319                                        case 7:
320                                                {
321                                                setState(157);
322                                                javadocInlineTag();
323                                                }
324                                                break;
325                                        }
326                                        } 
327                                }
328                                setState(162);
329                                _errHandler.sync(this);
330                                _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
331                        }
332                        setState(175);
333                        _errHandler.sync(this);
334                        _la = _input.LA(1);
335                        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)) {
336                                {
337                                {
338                                setState(164);
339                                _errHandler.sync(this);
340                                _la = _input.LA(1);
341                                if (_la==LEADING_ASTERISK) {
342                                        {
343                                        setState(163);
344                                        match(LEADING_ASTERISK);
345                                        }
346                                }
347
348                                setState(169);
349                                _errHandler.sync(this);
350                                _la = _input.LA(1);
351                                while (_la==WS) {
352                                        {
353                                        {
354                                        setState(166);
355                                        match(WS);
356                                        }
357                                        }
358                                        setState(171);
359                                        _errHandler.sync(this);
360                                        _la = _input.LA(1);
361                                }
362                                setState(172);
363                                javadocTag();
364                                }
365                                }
366                                setState(177);
367                                _errHandler.sync(this);
368                                _la = _input.LA(1);
369                        }
370                        setState(178);
371                        match(EOF);
372                        }
373                }
374                catch (RecognitionException re) {
375                        _localctx.exception = re;
376                        _errHandler.reportError(this, re);
377                        _errHandler.recover(this, re);
378                }
379                finally {
380                        exitRule();
381                }
382                return _localctx;
383        }
384
385        public static class HtmlElementContext extends ParserRuleContext {
386                public HtmlTagContext htmlTag() {
387                        return getRuleContext(HtmlTagContext.class,0);
388                }
389                public SingletonElementContext singletonElement() {
390                        return getRuleContext(SingletonElementContext.class,0);
391                }
392                public ParagraphContext paragraph() {
393                        return getRuleContext(ParagraphContext.class,0);
394                }
395                public LiContext li() {
396                        return getRuleContext(LiContext.class,0);
397                }
398                public TrContext tr() {
399                        return getRuleContext(TrContext.class,0);
400                }
401                public TdContext td() {
402                        return getRuleContext(TdContext.class,0);
403                }
404                public ThContext th() {
405                        return getRuleContext(ThContext.class,0);
406                }
407                public BodyContext body() {
408                        return getRuleContext(BodyContext.class,0);
409                }
410                public ColgroupContext colgroup() {
411                        return getRuleContext(ColgroupContext.class,0);
412                }
413                public DdContext dd() {
414                        return getRuleContext(DdContext.class,0);
415                }
416                public DtContext dt() {
417                        return getRuleContext(DtContext.class,0);
418                }
419                public HeadContext head() {
420                        return getRuleContext(HeadContext.class,0);
421                }
422                public HtmlContext html() {
423                        return getRuleContext(HtmlContext.class,0);
424                }
425                public OptionContext option() {
426                        return getRuleContext(OptionContext.class,0);
427                }
428                public TbodyContext tbody() {
429                        return getRuleContext(TbodyContext.class,0);
430                }
431                public TheadContext thead() {
432                        return getRuleContext(TheadContext.class,0);
433                }
434                public TfootContext tfoot() {
435                        return getRuleContext(TfootContext.class,0);
436                }
437                public PTagOpenContext pTagOpen() {
438                        return getRuleContext(PTagOpenContext.class,0);
439                }
440                public LiTagOpenContext liTagOpen() {
441                        return getRuleContext(LiTagOpenContext.class,0);
442                }
443                public TrTagOpenContext trTagOpen() {
444                        return getRuleContext(TrTagOpenContext.class,0);
445                }
446                public TdTagOpenContext tdTagOpen() {
447                        return getRuleContext(TdTagOpenContext.class,0);
448                }
449                public ThTagOpenContext thTagOpen() {
450                        return getRuleContext(ThTagOpenContext.class,0);
451                }
452                public BodyTagOpenContext bodyTagOpen() {
453                        return getRuleContext(BodyTagOpenContext.class,0);
454                }
455                public ColgroupTagOpenContext colgroupTagOpen() {
456                        return getRuleContext(ColgroupTagOpenContext.class,0);
457                }
458                public DdTagOpenContext ddTagOpen() {
459                        return getRuleContext(DdTagOpenContext.class,0);
460                }
461                public DtTagOpenContext dtTagOpen() {
462                        return getRuleContext(DtTagOpenContext.class,0);
463                }
464                public HeadTagOpenContext headTagOpen() {
465                        return getRuleContext(HeadTagOpenContext.class,0);
466                }
467                public HtmlTagOpenContext htmlTagOpen() {
468                        return getRuleContext(HtmlTagOpenContext.class,0);
469                }
470                public OptionTagOpenContext optionTagOpen() {
471                        return getRuleContext(OptionTagOpenContext.class,0);
472                }
473                public TbodyTagOpenContext tbodyTagOpen() {
474                        return getRuleContext(TbodyTagOpenContext.class,0);
475                }
476                public TheadTagOpenContext theadTagOpen() {
477                        return getRuleContext(TheadTagOpenContext.class,0);
478                }
479                public TfootTagOpenContext tfootTagOpen() {
480                        return getRuleContext(TfootTagOpenContext.class,0);
481                }
482                public PTagCloseContext pTagClose() {
483                        return getRuleContext(PTagCloseContext.class,0);
484                }
485                public LiTagCloseContext liTagClose() {
486                        return getRuleContext(LiTagCloseContext.class,0);
487                }
488                public TrTagCloseContext trTagClose() {
489                        return getRuleContext(TrTagCloseContext.class,0);
490                }
491                public TdTagCloseContext tdTagClose() {
492                        return getRuleContext(TdTagCloseContext.class,0);
493                }
494                public ThTagCloseContext thTagClose() {
495                        return getRuleContext(ThTagCloseContext.class,0);
496                }
497                public BodyTagCloseContext bodyTagClose() {
498                        return getRuleContext(BodyTagCloseContext.class,0);
499                }
500                public ColgroupTagCloseContext colgroupTagClose() {
501                        return getRuleContext(ColgroupTagCloseContext.class,0);
502                }
503                public DdTagCloseContext ddTagClose() {
504                        return getRuleContext(DdTagCloseContext.class,0);
505                }
506                public DtTagCloseContext dtTagClose() {
507                        return getRuleContext(DtTagCloseContext.class,0);
508                }
509                public HeadTagCloseContext headTagClose() {
510                        return getRuleContext(HeadTagCloseContext.class,0);
511                }
512                public HtmlTagCloseContext htmlTagClose() {
513                        return getRuleContext(HtmlTagCloseContext.class,0);
514                }
515                public OptionTagCloseContext optionTagClose() {
516                        return getRuleContext(OptionTagCloseContext.class,0);
517                }
518                public TbodyTagCloseContext tbodyTagClose() {
519                        return getRuleContext(TbodyTagCloseContext.class,0);
520                }
521                public TheadTagCloseContext theadTagClose() {
522                        return getRuleContext(TheadTagCloseContext.class,0);
523                }
524                public TfootTagCloseContext tfootTagClose() {
525                        return getRuleContext(TfootTagCloseContext.class,0);
526                }
527                public HtmlElementContext(ParserRuleContext parent, int invokingState) {
528                        super(parent, invokingState);
529                }
530                @Override public int getRuleIndex() { return RULE_htmlElement; }
531                @Override
532                public void enterRule(ParseTreeListener listener) {
533                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this);
534                }
535                @Override
536                public void exitRule(ParseTreeListener listener) {
537                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this);
538                }
539                @Override
540                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
541                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this);
542                        else return visitor.visitChildren(this);
543                }
544        }
545
546        public final HtmlElementContext htmlElement() throws RecognitionException {
547                HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
548                enterRule(_localctx, 2, RULE_htmlElement);
549                try {
550                        setState(227);
551                        _errHandler.sync(this);
552                        switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
553                        case 1:
554                                enterOuterAlt(_localctx, 1);
555                                {
556                                setState(180);
557                                htmlTag();
558                                }
559                                break;
560                        case 2:
561                                enterOuterAlt(_localctx, 2);
562                                {
563                                setState(181);
564                                singletonElement();
565                                }
566                                break;
567                        case 3:
568                                enterOuterAlt(_localctx, 3);
569                                {
570                                setState(182);
571                                paragraph();
572                                }
573                                break;
574                        case 4:
575                                enterOuterAlt(_localctx, 4);
576                                {
577                                setState(183);
578                                li();
579                                }
580                                break;
581                        case 5:
582                                enterOuterAlt(_localctx, 5);
583                                {
584                                setState(184);
585                                tr();
586                                }
587                                break;
588                        case 6:
589                                enterOuterAlt(_localctx, 6);
590                                {
591                                setState(185);
592                                td();
593                                }
594                                break;
595                        case 7:
596                                enterOuterAlt(_localctx, 7);
597                                {
598                                setState(186);
599                                th();
600                                }
601                                break;
602                        case 8:
603                                enterOuterAlt(_localctx, 8);
604                                {
605                                setState(187);
606                                body();
607                                }
608                                break;
609                        case 9:
610                                enterOuterAlt(_localctx, 9);
611                                {
612                                setState(188);
613                                colgroup();
614                                }
615                                break;
616                        case 10:
617                                enterOuterAlt(_localctx, 10);
618                                {
619                                setState(189);
620                                dd();
621                                }
622                                break;
623                        case 11:
624                                enterOuterAlt(_localctx, 11);
625                                {
626                                setState(190);
627                                dt();
628                                }
629                                break;
630                        case 12:
631                                enterOuterAlt(_localctx, 12);
632                                {
633                                setState(191);
634                                head();
635                                }
636                                break;
637                        case 13:
638                                enterOuterAlt(_localctx, 13);
639                                {
640                                setState(192);
641                                html();
642                                }
643                                break;
644                        case 14:
645                                enterOuterAlt(_localctx, 14);
646                                {
647                                setState(193);
648                                option();
649                                }
650                                break;
651                        case 15:
652                                enterOuterAlt(_localctx, 15);
653                                {
654                                setState(194);
655                                tbody();
656                                }
657                                break;
658                        case 16:
659                                enterOuterAlt(_localctx, 16);
660                                {
661                                setState(195);
662                                thead();
663                                }
664                                break;
665                        case 17:
666                                enterOuterAlt(_localctx, 17);
667                                {
668                                setState(196);
669                                tfoot();
670                                }
671                                break;
672                        case 18:
673                                enterOuterAlt(_localctx, 18);
674                                {
675                                setState(197);
676                                pTagOpen();
677                                }
678                                break;
679                        case 19:
680                                enterOuterAlt(_localctx, 19);
681                                {
682                                setState(198);
683                                liTagOpen();
684                                }
685                                break;
686                        case 20:
687                                enterOuterAlt(_localctx, 20);
688                                {
689                                setState(199);
690                                trTagOpen();
691                                }
692                                break;
693                        case 21:
694                                enterOuterAlt(_localctx, 21);
695                                {
696                                setState(200);
697                                tdTagOpen();
698                                }
699                                break;
700                        case 22:
701                                enterOuterAlt(_localctx, 22);
702                                {
703                                setState(201);
704                                thTagOpen();
705                                }
706                                break;
707                        case 23:
708                                enterOuterAlt(_localctx, 23);
709                                {
710                                setState(202);
711                                bodyTagOpen();
712                                }
713                                break;
714                        case 24:
715                                enterOuterAlt(_localctx, 24);
716                                {
717                                setState(203);
718                                colgroupTagOpen();
719                                }
720                                break;
721                        case 25:
722                                enterOuterAlt(_localctx, 25);
723                                {
724                                setState(204);
725                                ddTagOpen();
726                                }
727                                break;
728                        case 26:
729                                enterOuterAlt(_localctx, 26);
730                                {
731                                setState(205);
732                                dtTagOpen();
733                                }
734                                break;
735                        case 27:
736                                enterOuterAlt(_localctx, 27);
737                                {
738                                setState(206);
739                                headTagOpen();
740                                }
741                                break;
742                        case 28:
743                                enterOuterAlt(_localctx, 28);
744                                {
745                                setState(207);
746                                htmlTagOpen();
747                                }
748                                break;
749                        case 29:
750                                enterOuterAlt(_localctx, 29);
751                                {
752                                setState(208);
753                                optionTagOpen();
754                                }
755                                break;
756                        case 30:
757                                enterOuterAlt(_localctx, 30);
758                                {
759                                setState(209);
760                                tbodyTagOpen();
761                                }
762                                break;
763                        case 31:
764                                enterOuterAlt(_localctx, 31);
765                                {
766                                setState(210);
767                                theadTagOpen();
768                                }
769                                break;
770                        case 32:
771                                enterOuterAlt(_localctx, 32);
772                                {
773                                setState(211);
774                                tfootTagOpen();
775                                }
776                                break;
777                        case 33:
778                                enterOuterAlt(_localctx, 33);
779                                {
780                                setState(212);
781                                pTagClose();
782                                }
783                                break;
784                        case 34:
785                                enterOuterAlt(_localctx, 34);
786                                {
787                                setState(213);
788                                liTagClose();
789                                }
790                                break;
791                        case 35:
792                                enterOuterAlt(_localctx, 35);
793                                {
794                                setState(214);
795                                trTagClose();
796                                }
797                                break;
798                        case 36:
799                                enterOuterAlt(_localctx, 36);
800                                {
801                                setState(215);
802                                tdTagClose();
803                                }
804                                break;
805                        case 37:
806                                enterOuterAlt(_localctx, 37);
807                                {
808                                setState(216);
809                                thTagClose();
810                                }
811                                break;
812                        case 38:
813                                enterOuterAlt(_localctx, 38);
814                                {
815                                setState(217);
816                                bodyTagClose();
817                                }
818                                break;
819                        case 39:
820                                enterOuterAlt(_localctx, 39);
821                                {
822                                setState(218);
823                                colgroupTagClose();
824                                }
825                                break;
826                        case 40:
827                                enterOuterAlt(_localctx, 40);
828                                {
829                                setState(219);
830                                ddTagClose();
831                                }
832                                break;
833                        case 41:
834                                enterOuterAlt(_localctx, 41);
835                                {
836                                setState(220);
837                                dtTagClose();
838                                }
839                                break;
840                        case 42:
841                                enterOuterAlt(_localctx, 42);
842                                {
843                                setState(221);
844                                headTagClose();
845                                }
846                                break;
847                        case 43:
848                                enterOuterAlt(_localctx, 43);
849                                {
850                                setState(222);
851                                htmlTagClose();
852                                }
853                                break;
854                        case 44:
855                                enterOuterAlt(_localctx, 44);
856                                {
857                                setState(223);
858                                optionTagClose();
859                                }
860                                break;
861                        case 45:
862                                enterOuterAlt(_localctx, 45);
863                                {
864                                setState(224);
865                                tbodyTagClose();
866                                }
867                                break;
868                        case 46:
869                                enterOuterAlt(_localctx, 46);
870                                {
871                                setState(225);
872                                theadTagClose();
873                                }
874                                break;
875                        case 47:
876                                enterOuterAlt(_localctx, 47);
877                                {
878                                setState(226);
879                                tfootTagClose();
880                                }
881                                break;
882                        }
883                }
884                catch (RecognitionException re) {
885                        _localctx.exception = re;
886                        _errHandler.reportError(this, re);
887                        _errHandler.recover(this, re);
888                }
889                finally {
890                        exitRule();
891                }
892                return _localctx;
893        }
894
895        public static class HtmlElementOpenContext extends ParserRuleContext {
896                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
897                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
898                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
899                public List<AttributeContext> attribute() {
900                        return getRuleContexts(AttributeContext.class);
901                }
902                public AttributeContext attribute(int i) {
903                        return getRuleContext(AttributeContext.class,i);
904                }
905                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
906                public TerminalNode NEWLINE(int i) {
907                        return getToken(JavadocParser.NEWLINE, i);
908                }
909                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
910                public TerminalNode LEADING_ASTERISK(int i) {
911                        return getToken(JavadocParser.LEADING_ASTERISK, i);
912                }
913                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
914                public TerminalNode WS(int i) {
915                        return getToken(JavadocParser.WS, i);
916                }
917                public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) {
918                        super(parent, invokingState);
919                }
920                @Override public int getRuleIndex() { return RULE_htmlElementOpen; }
921                @Override
922                public void enterRule(ParseTreeListener listener) {
923                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this);
924                }
925                @Override
926                public void exitRule(ParseTreeListener listener) {
927                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this);
928                }
929                @Override
930                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
931                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this);
932                        else return visitor.visitChildren(this);
933                }
934        }
935
936        public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException {
937                HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState());
938                enterRule(_localctx, 4, RULE_htmlElementOpen);
939                int _la;
940                try {
941                        enterOuterAlt(_localctx, 1);
942                        {
943                        setState(229);
944                        match(OPEN);
945                        setState(230);
946                        match(HTML_TAG_NAME);
947                        setState(237);
948                        _errHandler.sync(this);
949                        _la = _input.LA(1);
950                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
951                                {
952                                setState(235);
953                                _errHandler.sync(this);
954                                switch (_input.LA(1)) {
955                                case HTML_TAG_NAME:
956                                        {
957                                        setState(231);
958                                        attribute();
959                                        }
960                                        break;
961                                case NEWLINE:
962                                        {
963                                        setState(232);
964                                        match(NEWLINE);
965                                        }
966                                        break;
967                                case LEADING_ASTERISK:
968                                        {
969                                        setState(233);
970                                        match(LEADING_ASTERISK);
971                                        }
972                                        break;
973                                case WS:
974                                        {
975                                        setState(234);
976                                        match(WS);
977                                        }
978                                        break;
979                                default:
980                                        throw new NoViableAltException(this);
981                                }
982                                }
983                                setState(239);
984                                _errHandler.sync(this);
985                                _la = _input.LA(1);
986                        }
987                        setState(240);
988                        match(CLOSE);
989                        }
990                }
991                catch (RecognitionException re) {
992                        _localctx.exception = re;
993                        _errHandler.reportError(this, re);
994                        _errHandler.recover(this, re);
995                }
996                finally {
997                        exitRule();
998                }
999                return _localctx;
1000        }
1001
1002        public static class HtmlElementCloseContext extends ParserRuleContext {
1003                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1004                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1005                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
1006                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1007                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1008                public TerminalNode NEWLINE(int i) {
1009                        return getToken(JavadocParser.NEWLINE, i);
1010                }
1011                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1012                public TerminalNode LEADING_ASTERISK(int i) {
1013                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1014                }
1015                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1016                public TerminalNode WS(int i) {
1017                        return getToken(JavadocParser.WS, i);
1018                }
1019                public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) {
1020                        super(parent, invokingState);
1021                }
1022                @Override public int getRuleIndex() { return RULE_htmlElementClose; }
1023                @Override
1024                public void enterRule(ParseTreeListener listener) {
1025                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this);
1026                }
1027                @Override
1028                public void exitRule(ParseTreeListener listener) {
1029                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this);
1030                }
1031                @Override
1032                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1033                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this);
1034                        else return visitor.visitChildren(this);
1035                }
1036        }
1037
1038        public final HtmlElementCloseContext htmlElementClose() throws RecognitionException {
1039                HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState());
1040                enterRule(_localctx, 6, RULE_htmlElementClose);
1041                int _la;
1042                try {
1043                        enterOuterAlt(_localctx, 1);
1044                        {
1045                        setState(242);
1046                        match(OPEN);
1047                        setState(243);
1048                        match(SLASH);
1049                        setState(244);
1050                        match(HTML_TAG_NAME);
1051                        setState(248);
1052                        _errHandler.sync(this);
1053                        _la = _input.LA(1);
1054                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1055                                {
1056                                {
1057                                setState(245);
1058                                _la = _input.LA(1);
1059                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1060                                _errHandler.recoverInline(this);
1061                                }
1062                                else {
1063                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1064                                        _errHandler.reportMatch(this);
1065                                        consume();
1066                                }
1067                                }
1068                                }
1069                                setState(250);
1070                                _errHandler.sync(this);
1071                                _la = _input.LA(1);
1072                        }
1073                        setState(251);
1074                        match(CLOSE);
1075                        }
1076                }
1077                catch (RecognitionException re) {
1078                        _localctx.exception = re;
1079                        _errHandler.reportError(this, re);
1080                        _errHandler.recover(this, re);
1081                }
1082                finally {
1083                        exitRule();
1084                }
1085                return _localctx;
1086        }
1087
1088        public static class AttributeContext extends ParserRuleContext {
1089                public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
1090                public TerminalNode HTML_TAG_NAME(int i) {
1091                        return getToken(JavadocParser.HTML_TAG_NAME, i);
1092                }
1093                public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
1094                public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
1095                public TextContext text() {
1096                        return getRuleContext(TextContext.class,0);
1097                }
1098                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1099                public TerminalNode NEWLINE(int i) {
1100                        return getToken(JavadocParser.NEWLINE, i);
1101                }
1102                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1103                public TerminalNode LEADING_ASTERISK(int i) {
1104                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1105                }
1106                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1107                public TerminalNode WS(int i) {
1108                        return getToken(JavadocParser.WS, i);
1109                }
1110                public AttributeContext(ParserRuleContext parent, int invokingState) {
1111                        super(parent, invokingState);
1112                }
1113                @Override public int getRuleIndex() { return RULE_attribute; }
1114                @Override
1115                public void enterRule(ParseTreeListener listener) {
1116                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this);
1117                }
1118                @Override
1119                public void exitRule(ParseTreeListener listener) {
1120                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this);
1121                }
1122                @Override
1123                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1124                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this);
1125                        else return visitor.visitChildren(this);
1126                }
1127        }
1128
1129        public final AttributeContext attribute() throws RecognitionException {
1130                AttributeContext _localctx = new AttributeContext(_ctx, getState());
1131                enterRule(_localctx, 8, RULE_attribute);
1132                int _la;
1133                try {
1134                        int _alt;
1135                        enterOuterAlt(_localctx, 1);
1136                        {
1137                        setState(253);
1138                        match(HTML_TAG_NAME);
1139                        setState(257);
1140                        _errHandler.sync(this);
1141                        _la = _input.LA(1);
1142                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1143                                {
1144                                {
1145                                setState(254);
1146                                _la = _input.LA(1);
1147                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1148                                _errHandler.recoverInline(this);
1149                                }
1150                                else {
1151                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1152                                        _errHandler.reportMatch(this);
1153                                        consume();
1154                                }
1155                                }
1156                                }
1157                                setState(259);
1158                                _errHandler.sync(this);
1159                                _la = _input.LA(1);
1160                        }
1161                        setState(260);
1162                        match(EQUALS);
1163                        setState(264);
1164                        _errHandler.sync(this);
1165                        _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1166                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1167                                if ( _alt==1 ) {
1168                                        {
1169                                        {
1170                                        setState(261);
1171                                        _la = _input.LA(1);
1172                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1173                                        _errHandler.recoverInline(this);
1174                                        }
1175                                        else {
1176                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1177                                                _errHandler.reportMatch(this);
1178                                                consume();
1179                                        }
1180                                        }
1181                                        } 
1182                                }
1183                                setState(266);
1184                                _errHandler.sync(this);
1185                                _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1186                        }
1187                        setState(270);
1188                        _errHandler.sync(this);
1189                        switch (_input.LA(1)) {
1190                        case ATTR_VALUE:
1191                                {
1192                                setState(267);
1193                                match(ATTR_VALUE);
1194                                }
1195                                break;
1196                        case WS:
1197                        case CHAR:
1198                                {
1199                                setState(268);
1200                                text();
1201                                }
1202                                break;
1203                        case HTML_TAG_NAME:
1204                                {
1205                                setState(269);
1206                                match(HTML_TAG_NAME);
1207                                }
1208                                break;
1209                        default:
1210                                throw new NoViableAltException(this);
1211                        }
1212                        }
1213                }
1214                catch (RecognitionException re) {
1215                        _localctx.exception = re;
1216                        _errHandler.reportError(this, re);
1217                        _errHandler.recover(this, re);
1218                }
1219                finally {
1220                        exitRule();
1221                }
1222                return _localctx;
1223        }
1224
1225        public static class HtmlTagContext extends ParserRuleContext {
1226                public HtmlElementOpenContext htmlElementOpen;
1227                public HtmlElementOpenContext htmlElementOpen() {
1228                        return getRuleContext(HtmlElementOpenContext.class,0);
1229                }
1230                public HtmlElementCloseContext htmlElementClose() {
1231                        return getRuleContext(HtmlElementCloseContext.class,0);
1232                }
1233                public List<HtmlElementContext> htmlElement() {
1234                        return getRuleContexts(HtmlElementContext.class);
1235                }
1236                public HtmlElementContext htmlElement(int i) {
1237                        return getRuleContext(HtmlElementContext.class,i);
1238                }
1239                public List<HtmlCommentContext> htmlComment() {
1240                        return getRuleContexts(HtmlCommentContext.class);
1241                }
1242                public HtmlCommentContext htmlComment(int i) {
1243                        return getRuleContext(HtmlCommentContext.class,i);
1244                }
1245                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1246                public TerminalNode CDATA(int i) {
1247                        return getToken(JavadocParser.CDATA, i);
1248                }
1249                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1250                public TerminalNode NEWLINE(int i) {
1251                        return getToken(JavadocParser.NEWLINE, i);
1252                }
1253                public List<TextContext> text() {
1254                        return getRuleContexts(TextContext.class);
1255                }
1256                public TextContext text(int i) {
1257                        return getRuleContext(TextContext.class,i);
1258                }
1259                public List<JavadocInlineTagContext> javadocInlineTag() {
1260                        return getRuleContexts(JavadocInlineTagContext.class);
1261                }
1262                public JavadocInlineTagContext javadocInlineTag(int i) {
1263                        return getRuleContext(JavadocInlineTagContext.class,i);
1264                }
1265                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1266                public TerminalNode LEADING_ASTERISK(int i) {
1267                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1268                }
1269                public HtmlTagContext(ParserRuleContext parent, int invokingState) {
1270                        super(parent, invokingState);
1271                }
1272                @Override public int getRuleIndex() { return RULE_htmlTag; }
1273                @Override
1274                public void enterRule(ParseTreeListener listener) {
1275                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this);
1276                }
1277                @Override
1278                public void exitRule(ParseTreeListener listener) {
1279                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this);
1280                }
1281                @Override
1282                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1283                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this);
1284                        else return visitor.visitChildren(this);
1285                }
1286        }
1287
1288        public final HtmlTagContext htmlTag() throws RecognitionException {
1289                HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1290                enterRule(_localctx, 10, RULE_htmlTag);
1291                try {
1292                        int _alt;
1293                        setState(304);
1294                        _errHandler.sync(this);
1295                        switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
1296                        case 1:
1297                                enterOuterAlt(_localctx, 1);
1298                                {
1299                                setState(272);
1300                                htmlElementOpen();
1301                                setState(283);
1302                                _errHandler.sync(this);
1303                                _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1304                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1305                                        if ( _alt==1 ) {
1306                                                {
1307                                                setState(281);
1308                                                _errHandler.sync(this);
1309                                                switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1310                                                case 1:
1311                                                        {
1312                                                        setState(273);
1313                                                        htmlElement();
1314                                                        }
1315                                                        break;
1316                                                case 2:
1317                                                        {
1318                                                        {
1319                                                        setState(274);
1320                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1321                                                        setState(275);
1322                                                        match(LEADING_ASTERISK);
1323                                                        }
1324                                                        }
1325                                                        break;
1326                                                case 3:
1327                                                        {
1328                                                        setState(276);
1329                                                        htmlComment();
1330                                                        }
1331                                                        break;
1332                                                case 4:
1333                                                        {
1334                                                        setState(277);
1335                                                        match(CDATA);
1336                                                        }
1337                                                        break;
1338                                                case 5:
1339                                                        {
1340                                                        setState(278);
1341                                                        match(NEWLINE);
1342                                                        }
1343                                                        break;
1344                                                case 6:
1345                                                        {
1346                                                        setState(279);
1347                                                        text();
1348                                                        }
1349                                                        break;
1350                                                case 7:
1351                                                        {
1352                                                        setState(280);
1353                                                        javadocInlineTag();
1354                                                        }
1355                                                        break;
1356                                                }
1357                                                } 
1358                                        }
1359                                        setState(285);
1360                                        _errHandler.sync(this);
1361                                        _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1362                                }
1363                                setState(286);
1364                                htmlElementClose();
1365                                }
1366                                break;
1367                        case 2:
1368                                enterOuterAlt(_localctx, 2);
1369                                {
1370                                setState(288);
1371                                ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen();
1372                                setState(299);
1373                                _errHandler.sync(this);
1374                                _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1375                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1376                                        if ( _alt==1 ) {
1377                                                {
1378                                                setState(297);
1379                                                _errHandler.sync(this);
1380                                                switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
1381                                                case 1:
1382                                                        {
1383                                                        setState(289);
1384                                                        htmlElement();
1385                                                        }
1386                                                        break;
1387                                                case 2:
1388                                                        {
1389                                                        {
1390                                                        setState(290);
1391                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1392                                                        setState(291);
1393                                                        match(LEADING_ASTERISK);
1394                                                        }
1395                                                        }
1396                                                        break;
1397                                                case 3:
1398                                                        {
1399                                                        setState(292);
1400                                                        htmlComment();
1401                                                        }
1402                                                        break;
1403                                                case 4:
1404                                                        {
1405                                                        setState(293);
1406                                                        match(CDATA);
1407                                                        }
1408                                                        break;
1409                                                case 5:
1410                                                        {
1411                                                        setState(294);
1412                                                        match(NEWLINE);
1413                                                        }
1414                                                        break;
1415                                                case 6:
1416                                                        {
1417                                                        setState(295);
1418                                                        text();
1419                                                        }
1420                                                        break;
1421                                                case 7:
1422                                                        {
1423                                                        setState(296);
1424                                                        javadocInlineTag();
1425                                                        }
1426                                                        break;
1427                                                }
1428                                                } 
1429                                        }
1430                                        setState(301);
1431                                        _errHandler.sync(this);
1432                                        _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1433                                }
1434                                notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol()
1435                                                                         , "javadoc.missed.html.close", null);
1436                                }
1437                                break;
1438                        }
1439                }
1440                catch (RecognitionException re) {
1441                        _localctx.exception = re;
1442                        _errHandler.reportError(this, re);
1443                        _errHandler.recover(this, re);
1444                }
1445                finally {
1446                        exitRule();
1447                }
1448                return _localctx;
1449        }
1450
1451        public static class PTagOpenContext extends ParserRuleContext {
1452                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1453                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1454                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1455                public List<AttributeContext> attribute() {
1456                        return getRuleContexts(AttributeContext.class);
1457                }
1458                public AttributeContext attribute(int i) {
1459                        return getRuleContext(AttributeContext.class,i);
1460                }
1461                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1462                public TerminalNode NEWLINE(int i) {
1463                        return getToken(JavadocParser.NEWLINE, i);
1464                }
1465                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1466                public TerminalNode LEADING_ASTERISK(int i) {
1467                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1468                }
1469                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1470                public TerminalNode WS(int i) {
1471                        return getToken(JavadocParser.WS, i);
1472                }
1473                public PTagOpenContext(ParserRuleContext parent, int invokingState) {
1474                        super(parent, invokingState);
1475                }
1476                @Override public int getRuleIndex() { return RULE_pTagOpen; }
1477                @Override
1478                public void enterRule(ParseTreeListener listener) {
1479                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this);
1480                }
1481                @Override
1482                public void exitRule(ParseTreeListener listener) {
1483                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this);
1484                }
1485                @Override
1486                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1487                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this);
1488                        else return visitor.visitChildren(this);
1489                }
1490        }
1491
1492        public final PTagOpenContext pTagOpen() throws RecognitionException {
1493                PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState());
1494                enterRule(_localctx, 12, RULE_pTagOpen);
1495                int _la;
1496                try {
1497                        enterOuterAlt(_localctx, 1);
1498                        {
1499                        setState(306);
1500                        match(OPEN);
1501                        setState(307);
1502                        match(P_HTML_TAG_NAME);
1503                        setState(314);
1504                        _errHandler.sync(this);
1505                        _la = _input.LA(1);
1506                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1507                                {
1508                                setState(312);
1509                                _errHandler.sync(this);
1510                                switch (_input.LA(1)) {
1511                                case HTML_TAG_NAME:
1512                                        {
1513                                        setState(308);
1514                                        attribute();
1515                                        }
1516                                        break;
1517                                case NEWLINE:
1518                                        {
1519                                        setState(309);
1520                                        match(NEWLINE);
1521                                        }
1522                                        break;
1523                                case LEADING_ASTERISK:
1524                                        {
1525                                        setState(310);
1526                                        match(LEADING_ASTERISK);
1527                                        }
1528                                        break;
1529                                case WS:
1530                                        {
1531                                        setState(311);
1532                                        match(WS);
1533                                        }
1534                                        break;
1535                                default:
1536                                        throw new NoViableAltException(this);
1537                                }
1538                                }
1539                                setState(316);
1540                                _errHandler.sync(this);
1541                                _la = _input.LA(1);
1542                        }
1543                        setState(317);
1544                        match(CLOSE);
1545                        }
1546                }
1547                catch (RecognitionException re) {
1548                        _localctx.exception = re;
1549                        _errHandler.reportError(this, re);
1550                        _errHandler.recover(this, re);
1551                }
1552                finally {
1553                        exitRule();
1554                }
1555                return _localctx;
1556        }
1557
1558        public static class PTagCloseContext extends ParserRuleContext {
1559                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1560                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1561                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1562                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1563                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1564                public TerminalNode NEWLINE(int i) {
1565                        return getToken(JavadocParser.NEWLINE, i);
1566                }
1567                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1568                public TerminalNode LEADING_ASTERISK(int i) {
1569                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1570                }
1571                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1572                public TerminalNode WS(int i) {
1573                        return getToken(JavadocParser.WS, i);
1574                }
1575                public PTagCloseContext(ParserRuleContext parent, int invokingState) {
1576                        super(parent, invokingState);
1577                }
1578                @Override public int getRuleIndex() { return RULE_pTagClose; }
1579                @Override
1580                public void enterRule(ParseTreeListener listener) {
1581                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this);
1582                }
1583                @Override
1584                public void exitRule(ParseTreeListener listener) {
1585                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this);
1586                }
1587                @Override
1588                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1589                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this);
1590                        else return visitor.visitChildren(this);
1591                }
1592        }
1593
1594        public final PTagCloseContext pTagClose() throws RecognitionException {
1595                PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState());
1596                enterRule(_localctx, 14, RULE_pTagClose);
1597                int _la;
1598                try {
1599                        enterOuterAlt(_localctx, 1);
1600                        {
1601                        setState(319);
1602                        match(OPEN);
1603                        setState(320);
1604                        match(SLASH);
1605                        setState(321);
1606                        match(P_HTML_TAG_NAME);
1607                        setState(325);
1608                        _errHandler.sync(this);
1609                        _la = _input.LA(1);
1610                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1611                                {
1612                                {
1613                                setState(322);
1614                                _la = _input.LA(1);
1615                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1616                                _errHandler.recoverInline(this);
1617                                }
1618                                else {
1619                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
1620                                        _errHandler.reportMatch(this);
1621                                        consume();
1622                                }
1623                                }
1624                                }
1625                                setState(327);
1626                                _errHandler.sync(this);
1627                                _la = _input.LA(1);
1628                        }
1629                        setState(328);
1630                        match(CLOSE);
1631                        }
1632                }
1633                catch (RecognitionException re) {
1634                        _localctx.exception = re;
1635                        _errHandler.reportError(this, re);
1636                        _errHandler.recover(this, re);
1637                }
1638                finally {
1639                        exitRule();
1640                }
1641                return _localctx;
1642        }
1643
1644        public static class ParagraphContext extends ParserRuleContext {
1645                public PTagOpenContext pTagOpen() {
1646                        return getRuleContext(PTagOpenContext.class,0);
1647                }
1648                public PTagCloseContext pTagClose() {
1649                        return getRuleContext(PTagCloseContext.class,0);
1650                }
1651                public List<HtmlTagContext> htmlTag() {
1652                        return getRuleContexts(HtmlTagContext.class);
1653                }
1654                public HtmlTagContext htmlTag(int i) {
1655                        return getRuleContext(HtmlTagContext.class,i);
1656                }
1657                public List<SingletonTagContext> singletonTag() {
1658                        return getRuleContexts(SingletonTagContext.class);
1659                }
1660                public SingletonTagContext singletonTag(int i) {
1661                        return getRuleContext(SingletonTagContext.class,i);
1662                }
1663                public List<LiContext> li() {
1664                        return getRuleContexts(LiContext.class);
1665                }
1666                public LiContext li(int i) {
1667                        return getRuleContext(LiContext.class,i);
1668                }
1669                public List<TrContext> tr() {
1670                        return getRuleContexts(TrContext.class);
1671                }
1672                public TrContext tr(int i) {
1673                        return getRuleContext(TrContext.class,i);
1674                }
1675                public List<TdContext> td() {
1676                        return getRuleContexts(TdContext.class);
1677                }
1678                public TdContext td(int i) {
1679                        return getRuleContext(TdContext.class,i);
1680                }
1681                public List<ThContext> th() {
1682                        return getRuleContexts(ThContext.class);
1683                }
1684                public ThContext th(int i) {
1685                        return getRuleContext(ThContext.class,i);
1686                }
1687                public List<BodyContext> body() {
1688                        return getRuleContexts(BodyContext.class);
1689                }
1690                public BodyContext body(int i) {
1691                        return getRuleContext(BodyContext.class,i);
1692                }
1693                public List<ColgroupContext> colgroup() {
1694                        return getRuleContexts(ColgroupContext.class);
1695                }
1696                public ColgroupContext colgroup(int i) {
1697                        return getRuleContext(ColgroupContext.class,i);
1698                }
1699                public List<DdContext> dd() {
1700                        return getRuleContexts(DdContext.class);
1701                }
1702                public DdContext dd(int i) {
1703                        return getRuleContext(DdContext.class,i);
1704                }
1705                public List<DtContext> dt() {
1706                        return getRuleContexts(DtContext.class);
1707                }
1708                public DtContext dt(int i) {
1709                        return getRuleContext(DtContext.class,i);
1710                }
1711                public List<HeadContext> head() {
1712                        return getRuleContexts(HeadContext.class);
1713                }
1714                public HeadContext head(int i) {
1715                        return getRuleContext(HeadContext.class,i);
1716                }
1717                public List<HtmlContext> html() {
1718                        return getRuleContexts(HtmlContext.class);
1719                }
1720                public HtmlContext html(int i) {
1721                        return getRuleContext(HtmlContext.class,i);
1722                }
1723                public List<OptionContext> option() {
1724                        return getRuleContexts(OptionContext.class);
1725                }
1726                public OptionContext option(int i) {
1727                        return getRuleContext(OptionContext.class,i);
1728                }
1729                public List<TbodyContext> tbody() {
1730                        return getRuleContexts(TbodyContext.class);
1731                }
1732                public TbodyContext tbody(int i) {
1733                        return getRuleContext(TbodyContext.class,i);
1734                }
1735                public List<TheadContext> thead() {
1736                        return getRuleContexts(TheadContext.class);
1737                }
1738                public TheadContext thead(int i) {
1739                        return getRuleContext(TheadContext.class,i);
1740                }
1741                public List<TfootContext> tfoot() {
1742                        return getRuleContexts(TfootContext.class);
1743                }
1744                public TfootContext tfoot(int i) {
1745                        return getRuleContext(TfootContext.class,i);
1746                }
1747                public List<LiTagOpenContext> liTagOpen() {
1748                        return getRuleContexts(LiTagOpenContext.class);
1749                }
1750                public LiTagOpenContext liTagOpen(int i) {
1751                        return getRuleContext(LiTagOpenContext.class,i);
1752                }
1753                public List<TrTagOpenContext> trTagOpen() {
1754                        return getRuleContexts(TrTagOpenContext.class);
1755                }
1756                public TrTagOpenContext trTagOpen(int i) {
1757                        return getRuleContext(TrTagOpenContext.class,i);
1758                }
1759                public List<TdTagOpenContext> tdTagOpen() {
1760                        return getRuleContexts(TdTagOpenContext.class);
1761                }
1762                public TdTagOpenContext tdTagOpen(int i) {
1763                        return getRuleContext(TdTagOpenContext.class,i);
1764                }
1765                public List<ThTagOpenContext> thTagOpen() {
1766                        return getRuleContexts(ThTagOpenContext.class);
1767                }
1768                public ThTagOpenContext thTagOpen(int i) {
1769                        return getRuleContext(ThTagOpenContext.class,i);
1770                }
1771                public List<BodyTagOpenContext> bodyTagOpen() {
1772                        return getRuleContexts(BodyTagOpenContext.class);
1773                }
1774                public BodyTagOpenContext bodyTagOpen(int i) {
1775                        return getRuleContext(BodyTagOpenContext.class,i);
1776                }
1777                public List<ColgroupTagOpenContext> colgroupTagOpen() {
1778                        return getRuleContexts(ColgroupTagOpenContext.class);
1779                }
1780                public ColgroupTagOpenContext colgroupTagOpen(int i) {
1781                        return getRuleContext(ColgroupTagOpenContext.class,i);
1782                }
1783                public List<DdTagOpenContext> ddTagOpen() {
1784                        return getRuleContexts(DdTagOpenContext.class);
1785                }
1786                public DdTagOpenContext ddTagOpen(int i) {
1787                        return getRuleContext(DdTagOpenContext.class,i);
1788                }
1789                public List<DtTagOpenContext> dtTagOpen() {
1790                        return getRuleContexts(DtTagOpenContext.class);
1791                }
1792                public DtTagOpenContext dtTagOpen(int i) {
1793                        return getRuleContext(DtTagOpenContext.class,i);
1794                }
1795                public List<HeadTagOpenContext> headTagOpen() {
1796                        return getRuleContexts(HeadTagOpenContext.class);
1797                }
1798                public HeadTagOpenContext headTagOpen(int i) {
1799                        return getRuleContext(HeadTagOpenContext.class,i);
1800                }
1801                public List<HtmlTagOpenContext> htmlTagOpen() {
1802                        return getRuleContexts(HtmlTagOpenContext.class);
1803                }
1804                public HtmlTagOpenContext htmlTagOpen(int i) {
1805                        return getRuleContext(HtmlTagOpenContext.class,i);
1806                }
1807                public List<OptionTagOpenContext> optionTagOpen() {
1808                        return getRuleContexts(OptionTagOpenContext.class);
1809                }
1810                public OptionTagOpenContext optionTagOpen(int i) {
1811                        return getRuleContext(OptionTagOpenContext.class,i);
1812                }
1813                public List<TbodyTagOpenContext> tbodyTagOpen() {
1814                        return getRuleContexts(TbodyTagOpenContext.class);
1815                }
1816                public TbodyTagOpenContext tbodyTagOpen(int i) {
1817                        return getRuleContext(TbodyTagOpenContext.class,i);
1818                }
1819                public List<TheadTagOpenContext> theadTagOpen() {
1820                        return getRuleContexts(TheadTagOpenContext.class);
1821                }
1822                public TheadTagOpenContext theadTagOpen(int i) {
1823                        return getRuleContext(TheadTagOpenContext.class,i);
1824                }
1825                public List<TfootTagOpenContext> tfootTagOpen() {
1826                        return getRuleContexts(TfootTagOpenContext.class);
1827                }
1828                public TfootTagOpenContext tfootTagOpen(int i) {
1829                        return getRuleContext(TfootTagOpenContext.class,i);
1830                }
1831                public List<HtmlCommentContext> htmlComment() {
1832                        return getRuleContexts(HtmlCommentContext.class);
1833                }
1834                public HtmlCommentContext htmlComment(int i) {
1835                        return getRuleContext(HtmlCommentContext.class,i);
1836                }
1837                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1838                public TerminalNode CDATA(int i) {
1839                        return getToken(JavadocParser.CDATA, i);
1840                }
1841                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1842                public TerminalNode NEWLINE(int i) {
1843                        return getToken(JavadocParser.NEWLINE, i);
1844                }
1845                public List<TextContext> text() {
1846                        return getRuleContexts(TextContext.class);
1847                }
1848                public TextContext text(int i) {
1849                        return getRuleContext(TextContext.class,i);
1850                }
1851                public List<JavadocInlineTagContext> javadocInlineTag() {
1852                        return getRuleContexts(JavadocInlineTagContext.class);
1853                }
1854                public JavadocInlineTagContext javadocInlineTag(int i) {
1855                        return getRuleContext(JavadocInlineTagContext.class,i);
1856                }
1857                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1858                public TerminalNode LEADING_ASTERISK(int i) {
1859                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1860                }
1861                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1862                        super(parent, invokingState);
1863                }
1864                @Override public int getRuleIndex() { return RULE_paragraph; }
1865                @Override
1866                public void enterRule(ParseTreeListener listener) {
1867                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this);
1868                }
1869                @Override
1870                public void exitRule(ParseTreeListener listener) {
1871                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this);
1872                }
1873                @Override
1874                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1875                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this);
1876                        else return visitor.visitChildren(this);
1877                }
1878        }
1879
1880        public final ParagraphContext paragraph() throws RecognitionException {
1881                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1882                enterRule(_localctx, 16, RULE_paragraph);
1883                try {
1884                        int _alt;
1885                        enterOuterAlt(_localctx, 1);
1886                        {
1887                        setState(330);
1888                        pTagOpen();
1889                        setState(370);
1890                        _errHandler.sync(this);
1891                        _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1892                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1893                                if ( _alt==1 ) {
1894                                        {
1895                                        setState(368);
1896                                        _errHandler.sync(this);
1897                                        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
1898                                        case 1:
1899                                                {
1900                                                setState(331);
1901                                                htmlTag();
1902                                                }
1903                                                break;
1904                                        case 2:
1905                                                {
1906                                                setState(332);
1907                                                singletonTag();
1908                                                }
1909                                                break;
1910                                        case 3:
1911                                                {
1912                                                setState(333);
1913                                                li();
1914                                                }
1915                                                break;
1916                                        case 4:
1917                                                {
1918                                                setState(334);
1919                                                tr();
1920                                                }
1921                                                break;
1922                                        case 5:
1923                                                {
1924                                                setState(335);
1925                                                td();
1926                                                }
1927                                                break;
1928                                        case 6:
1929                                                {
1930                                                setState(336);
1931                                                th();
1932                                                }
1933                                                break;
1934                                        case 7:
1935                                                {
1936                                                setState(337);
1937                                                body();
1938                                                }
1939                                                break;
1940                                        case 8:
1941                                                {
1942                                                setState(338);
1943                                                colgroup();
1944                                                }
1945                                                break;
1946                                        case 9:
1947                                                {
1948                                                setState(339);
1949                                                dd();
1950                                                }
1951                                                break;
1952                                        case 10:
1953                                                {
1954                                                setState(340);
1955                                                dt();
1956                                                }
1957                                                break;
1958                                        case 11:
1959                                                {
1960                                                setState(341);
1961                                                head();
1962                                                }
1963                                                break;
1964                                        case 12:
1965                                                {
1966                                                setState(342);
1967                                                html();
1968                                                }
1969                                                break;
1970                                        case 13:
1971                                                {
1972                                                setState(343);
1973                                                option();
1974                                                }
1975                                                break;
1976                                        case 14:
1977                                                {
1978                                                setState(344);
1979                                                tbody();
1980                                                }
1981                                                break;
1982                                        case 15:
1983                                                {
1984                                                setState(345);
1985                                                thead();
1986                                                }
1987                                                break;
1988                                        case 16:
1989                                                {
1990                                                setState(346);
1991                                                tfoot();
1992                                                }
1993                                                break;
1994                                        case 17:
1995                                                {
1996                                                setState(347);
1997                                                liTagOpen();
1998                                                }
1999                                                break;
2000                                        case 18:
2001                                                {
2002                                                setState(348);
2003                                                trTagOpen();
2004                                                }
2005                                                break;
2006                                        case 19:
2007                                                {
2008                                                setState(349);
2009                                                tdTagOpen();
2010                                                }
2011                                                break;
2012                                        case 20:
2013                                                {
2014                                                setState(350);
2015                                                thTagOpen();
2016                                                }
2017                                                break;
2018                                        case 21:
2019                                                {
2020                                                setState(351);
2021                                                bodyTagOpen();
2022                                                }
2023                                                break;
2024                                        case 22:
2025                                                {
2026                                                setState(352);
2027                                                colgroupTagOpen();
2028                                                }
2029                                                break;
2030                                        case 23:
2031                                                {
2032                                                setState(353);
2033                                                ddTagOpen();
2034                                                }
2035                                                break;
2036                                        case 24:
2037                                                {
2038                                                setState(354);
2039                                                dtTagOpen();
2040                                                }
2041                                                break;
2042                                        case 25:
2043                                                {
2044                                                setState(355);
2045                                                headTagOpen();
2046                                                }
2047                                                break;
2048                                        case 26:
2049                                                {
2050                                                setState(356);
2051                                                htmlTagOpen();
2052                                                }
2053                                                break;
2054                                        case 27:
2055                                                {
2056                                                setState(357);
2057                                                optionTagOpen();
2058                                                }
2059                                                break;
2060                                        case 28:
2061                                                {
2062                                                setState(358);
2063                                                tbodyTagOpen();
2064                                                }
2065                                                break;
2066                                        case 29:
2067                                                {
2068                                                setState(359);
2069                                                theadTagOpen();
2070                                                }
2071                                                break;
2072                                        case 30:
2073                                                {
2074                                                setState(360);
2075                                                tfootTagOpen();
2076                                                }
2077                                                break;
2078                                        case 31:
2079                                                {
2080                                                {
2081                                                setState(361);
2082                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2083                                                setState(362);
2084                                                match(LEADING_ASTERISK);
2085                                                }
2086                                                }
2087                                                break;
2088                                        case 32:
2089                                                {
2090                                                setState(363);
2091                                                htmlComment();
2092                                                }
2093                                                break;
2094                                        case 33:
2095                                                {
2096                                                setState(364);
2097                                                match(CDATA);
2098                                                }
2099                                                break;
2100                                        case 34:
2101                                                {
2102                                                setState(365);
2103                                                match(NEWLINE);
2104                                                }
2105                                                break;
2106                                        case 35:
2107                                                {
2108                                                setState(366);
2109                                                text();
2110                                                }
2111                                                break;
2112                                        case 36:
2113                                                {
2114                                                setState(367);
2115                                                javadocInlineTag();
2116                                                }
2117                                                break;
2118                                        }
2119                                        } 
2120                                }
2121                                setState(372);
2122                                _errHandler.sync(this);
2123                                _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
2124                        }
2125                        setState(373);
2126                        pTagClose();
2127                        }
2128                }
2129                catch (RecognitionException re) {
2130                        _localctx.exception = re;
2131                        _errHandler.reportError(this, re);
2132                        _errHandler.recover(this, re);
2133                }
2134                finally {
2135                        exitRule();
2136                }
2137                return _localctx;
2138        }
2139
2140        public static class LiTagOpenContext extends ParserRuleContext {
2141                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2142                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2143                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2144                public List<AttributeContext> attribute() {
2145                        return getRuleContexts(AttributeContext.class);
2146                }
2147                public AttributeContext attribute(int i) {
2148                        return getRuleContext(AttributeContext.class,i);
2149                }
2150                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2151                public TerminalNode NEWLINE(int i) {
2152                        return getToken(JavadocParser.NEWLINE, i);
2153                }
2154                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2155                public TerminalNode LEADING_ASTERISK(int i) {
2156                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2157                }
2158                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2159                public TerminalNode WS(int i) {
2160                        return getToken(JavadocParser.WS, i);
2161                }
2162                public LiTagOpenContext(ParserRuleContext parent, int invokingState) {
2163                        super(parent, invokingState);
2164                }
2165                @Override public int getRuleIndex() { return RULE_liTagOpen; }
2166                @Override
2167                public void enterRule(ParseTreeListener listener) {
2168                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this);
2169                }
2170                @Override
2171                public void exitRule(ParseTreeListener listener) {
2172                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this);
2173                }
2174                @Override
2175                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2176                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this);
2177                        else return visitor.visitChildren(this);
2178                }
2179        }
2180
2181        public final LiTagOpenContext liTagOpen() throws RecognitionException {
2182                LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState());
2183                enterRule(_localctx, 18, RULE_liTagOpen);
2184                int _la;
2185                try {
2186                        enterOuterAlt(_localctx, 1);
2187                        {
2188                        setState(375);
2189                        match(OPEN);
2190                        setState(376);
2191                        match(LI_HTML_TAG_NAME);
2192                        setState(383);
2193                        _errHandler.sync(this);
2194                        _la = _input.LA(1);
2195                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2196                                {
2197                                setState(381);
2198                                _errHandler.sync(this);
2199                                switch (_input.LA(1)) {
2200                                case HTML_TAG_NAME:
2201                                        {
2202                                        setState(377);
2203                                        attribute();
2204                                        }
2205                                        break;
2206                                case NEWLINE:
2207                                        {
2208                                        setState(378);
2209                                        match(NEWLINE);
2210                                        }
2211                                        break;
2212                                case LEADING_ASTERISK:
2213                                        {
2214                                        setState(379);
2215                                        match(LEADING_ASTERISK);
2216                                        }
2217                                        break;
2218                                case WS:
2219                                        {
2220                                        setState(380);
2221                                        match(WS);
2222                                        }
2223                                        break;
2224                                default:
2225                                        throw new NoViableAltException(this);
2226                                }
2227                                }
2228                                setState(385);
2229                                _errHandler.sync(this);
2230                                _la = _input.LA(1);
2231                        }
2232                        setState(386);
2233                        match(CLOSE);
2234                        }
2235                }
2236                catch (RecognitionException re) {
2237                        _localctx.exception = re;
2238                        _errHandler.reportError(this, re);
2239                        _errHandler.recover(this, re);
2240                }
2241                finally {
2242                        exitRule();
2243                }
2244                return _localctx;
2245        }
2246
2247        public static class LiTagCloseContext extends ParserRuleContext {
2248                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2249                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2250                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2251                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2252                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2253                public TerminalNode NEWLINE(int i) {
2254                        return getToken(JavadocParser.NEWLINE, i);
2255                }
2256                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2257                public TerminalNode LEADING_ASTERISK(int i) {
2258                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2259                }
2260                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2261                public TerminalNode WS(int i) {
2262                        return getToken(JavadocParser.WS, i);
2263                }
2264                public LiTagCloseContext(ParserRuleContext parent, int invokingState) {
2265                        super(parent, invokingState);
2266                }
2267                @Override public int getRuleIndex() { return RULE_liTagClose; }
2268                @Override
2269                public void enterRule(ParseTreeListener listener) {
2270                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this);
2271                }
2272                @Override
2273                public void exitRule(ParseTreeListener listener) {
2274                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this);
2275                }
2276                @Override
2277                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2278                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this);
2279                        else return visitor.visitChildren(this);
2280                }
2281        }
2282
2283        public final LiTagCloseContext liTagClose() throws RecognitionException {
2284                LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState());
2285                enterRule(_localctx, 20, RULE_liTagClose);
2286                int _la;
2287                try {
2288                        enterOuterAlt(_localctx, 1);
2289                        {
2290                        setState(388);
2291                        match(OPEN);
2292                        setState(389);
2293                        match(SLASH);
2294                        setState(390);
2295                        match(LI_HTML_TAG_NAME);
2296                        setState(394);
2297                        _errHandler.sync(this);
2298                        _la = _input.LA(1);
2299                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2300                                {
2301                                {
2302                                setState(391);
2303                                _la = _input.LA(1);
2304                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2305                                _errHandler.recoverInline(this);
2306                                }
2307                                else {
2308                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
2309                                        _errHandler.reportMatch(this);
2310                                        consume();
2311                                }
2312                                }
2313                                }
2314                                setState(396);
2315                                _errHandler.sync(this);
2316                                _la = _input.LA(1);
2317                        }
2318                        setState(397);
2319                        match(CLOSE);
2320                        }
2321                }
2322                catch (RecognitionException re) {
2323                        _localctx.exception = re;
2324                        _errHandler.reportError(this, re);
2325                        _errHandler.recover(this, re);
2326                }
2327                finally {
2328                        exitRule();
2329                }
2330                return _localctx;
2331        }
2332
2333        public static class LiContext extends ParserRuleContext {
2334                public LiTagOpenContext liTagOpen() {
2335                        return getRuleContext(LiTagOpenContext.class,0);
2336                }
2337                public LiTagCloseContext liTagClose() {
2338                        return getRuleContext(LiTagCloseContext.class,0);
2339                }
2340                public List<HtmlTagContext> htmlTag() {
2341                        return getRuleContexts(HtmlTagContext.class);
2342                }
2343                public HtmlTagContext htmlTag(int i) {
2344                        return getRuleContext(HtmlTagContext.class,i);
2345                }
2346                public List<SingletonTagContext> singletonTag() {
2347                        return getRuleContexts(SingletonTagContext.class);
2348                }
2349                public SingletonTagContext singletonTag(int i) {
2350                        return getRuleContext(SingletonTagContext.class,i);
2351                }
2352                public List<ParagraphContext> paragraph() {
2353                        return getRuleContexts(ParagraphContext.class);
2354                }
2355                public ParagraphContext paragraph(int i) {
2356                        return getRuleContext(ParagraphContext.class,i);
2357                }
2358                public List<TrContext> tr() {
2359                        return getRuleContexts(TrContext.class);
2360                }
2361                public TrContext tr(int i) {
2362                        return getRuleContext(TrContext.class,i);
2363                }
2364                public List<TdContext> td() {
2365                        return getRuleContexts(TdContext.class);
2366                }
2367                public TdContext td(int i) {
2368                        return getRuleContext(TdContext.class,i);
2369                }
2370                public List<ThContext> th() {
2371                        return getRuleContexts(ThContext.class);
2372                }
2373                public ThContext th(int i) {
2374                        return getRuleContext(ThContext.class,i);
2375                }
2376                public List<BodyContext> body() {
2377                        return getRuleContexts(BodyContext.class);
2378                }
2379                public BodyContext body(int i) {
2380                        return getRuleContext(BodyContext.class,i);
2381                }
2382                public List<ColgroupContext> colgroup() {
2383                        return getRuleContexts(ColgroupContext.class);
2384                }
2385                public ColgroupContext colgroup(int i) {
2386                        return getRuleContext(ColgroupContext.class,i);
2387                }
2388                public List<DdContext> dd() {
2389                        return getRuleContexts(DdContext.class);
2390                }
2391                public DdContext dd(int i) {
2392                        return getRuleContext(DdContext.class,i);
2393                }
2394                public List<DtContext> dt() {
2395                        return getRuleContexts(DtContext.class);
2396                }
2397                public DtContext dt(int i) {
2398                        return getRuleContext(DtContext.class,i);
2399                }
2400                public List<HeadContext> head() {
2401                        return getRuleContexts(HeadContext.class);
2402                }
2403                public HeadContext head(int i) {
2404                        return getRuleContext(HeadContext.class,i);
2405                }
2406                public List<HtmlContext> html() {
2407                        return getRuleContexts(HtmlContext.class);
2408                }
2409                public HtmlContext html(int i) {
2410                        return getRuleContext(HtmlContext.class,i);
2411                }
2412                public List<OptionContext> option() {
2413                        return getRuleContexts(OptionContext.class);
2414                }
2415                public OptionContext option(int i) {
2416                        return getRuleContext(OptionContext.class,i);
2417                }
2418                public List<TbodyContext> tbody() {
2419                        return getRuleContexts(TbodyContext.class);
2420                }
2421                public TbodyContext tbody(int i) {
2422                        return getRuleContext(TbodyContext.class,i);
2423                }
2424                public List<TheadContext> thead() {
2425                        return getRuleContexts(TheadContext.class);
2426                }
2427                public TheadContext thead(int i) {
2428                        return getRuleContext(TheadContext.class,i);
2429                }
2430                public List<TfootContext> tfoot() {
2431                        return getRuleContexts(TfootContext.class);
2432                }
2433                public TfootContext tfoot(int i) {
2434                        return getRuleContext(TfootContext.class,i);
2435                }
2436                public List<PTagOpenContext> pTagOpen() {
2437                        return getRuleContexts(PTagOpenContext.class);
2438                }
2439                public PTagOpenContext pTagOpen(int i) {
2440                        return getRuleContext(PTagOpenContext.class,i);
2441                }
2442                public List<TrTagOpenContext> trTagOpen() {
2443                        return getRuleContexts(TrTagOpenContext.class);
2444                }
2445                public TrTagOpenContext trTagOpen(int i) {
2446                        return getRuleContext(TrTagOpenContext.class,i);
2447                }
2448                public List<TdTagOpenContext> tdTagOpen() {
2449                        return getRuleContexts(TdTagOpenContext.class);
2450                }
2451                public TdTagOpenContext tdTagOpen(int i) {
2452                        return getRuleContext(TdTagOpenContext.class,i);
2453                }
2454                public List<ThTagOpenContext> thTagOpen() {
2455                        return getRuleContexts(ThTagOpenContext.class);
2456                }
2457                public ThTagOpenContext thTagOpen(int i) {
2458                        return getRuleContext(ThTagOpenContext.class,i);
2459                }
2460                public List<BodyTagOpenContext> bodyTagOpen() {
2461                        return getRuleContexts(BodyTagOpenContext.class);
2462                }
2463                public BodyTagOpenContext bodyTagOpen(int i) {
2464                        return getRuleContext(BodyTagOpenContext.class,i);
2465                }
2466                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2467                        return getRuleContexts(ColgroupTagOpenContext.class);
2468                }
2469                public ColgroupTagOpenContext colgroupTagOpen(int i) {
2470                        return getRuleContext(ColgroupTagOpenContext.class,i);
2471                }
2472                public List<DdTagOpenContext> ddTagOpen() {
2473                        return getRuleContexts(DdTagOpenContext.class);
2474                }
2475                public DdTagOpenContext ddTagOpen(int i) {
2476                        return getRuleContext(DdTagOpenContext.class,i);
2477                }
2478                public List<DtTagOpenContext> dtTagOpen() {
2479                        return getRuleContexts(DtTagOpenContext.class);
2480                }
2481                public DtTagOpenContext dtTagOpen(int i) {
2482                        return getRuleContext(DtTagOpenContext.class,i);
2483                }
2484                public List<HeadTagOpenContext> headTagOpen() {
2485                        return getRuleContexts(HeadTagOpenContext.class);
2486                }
2487                public HeadTagOpenContext headTagOpen(int i) {
2488                        return getRuleContext(HeadTagOpenContext.class,i);
2489                }
2490                public List<HtmlTagOpenContext> htmlTagOpen() {
2491                        return getRuleContexts(HtmlTagOpenContext.class);
2492                }
2493                public HtmlTagOpenContext htmlTagOpen(int i) {
2494                        return getRuleContext(HtmlTagOpenContext.class,i);
2495                }
2496                public List<OptionTagOpenContext> optionTagOpen() {
2497                        return getRuleContexts(OptionTagOpenContext.class);
2498                }
2499                public OptionTagOpenContext optionTagOpen(int i) {
2500                        return getRuleContext(OptionTagOpenContext.class,i);
2501                }
2502                public List<TbodyTagOpenContext> tbodyTagOpen() {
2503                        return getRuleContexts(TbodyTagOpenContext.class);
2504                }
2505                public TbodyTagOpenContext tbodyTagOpen(int i) {
2506                        return getRuleContext(TbodyTagOpenContext.class,i);
2507                }
2508                public List<TheadTagOpenContext> theadTagOpen() {
2509                        return getRuleContexts(TheadTagOpenContext.class);
2510                }
2511                public TheadTagOpenContext theadTagOpen(int i) {
2512                        return getRuleContext(TheadTagOpenContext.class,i);
2513                }
2514                public List<TfootTagOpenContext> tfootTagOpen() {
2515                        return getRuleContexts(TfootTagOpenContext.class);
2516                }
2517                public TfootTagOpenContext tfootTagOpen(int i) {
2518                        return getRuleContext(TfootTagOpenContext.class,i);
2519                }
2520                public List<HtmlCommentContext> htmlComment() {
2521                        return getRuleContexts(HtmlCommentContext.class);
2522                }
2523                public HtmlCommentContext htmlComment(int i) {
2524                        return getRuleContext(HtmlCommentContext.class,i);
2525                }
2526                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2527                public TerminalNode CDATA(int i) {
2528                        return getToken(JavadocParser.CDATA, i);
2529                }
2530                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2531                public TerminalNode NEWLINE(int i) {
2532                        return getToken(JavadocParser.NEWLINE, i);
2533                }
2534                public List<TextContext> text() {
2535                        return getRuleContexts(TextContext.class);
2536                }
2537                public TextContext text(int i) {
2538                        return getRuleContext(TextContext.class,i);
2539                }
2540                public List<JavadocInlineTagContext> javadocInlineTag() {
2541                        return getRuleContexts(JavadocInlineTagContext.class);
2542                }
2543                public JavadocInlineTagContext javadocInlineTag(int i) {
2544                        return getRuleContext(JavadocInlineTagContext.class,i);
2545                }
2546                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2547                public TerminalNode LEADING_ASTERISK(int i) {
2548                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2549                }
2550                public LiContext(ParserRuleContext parent, int invokingState) {
2551                        super(parent, invokingState);
2552                }
2553                @Override public int getRuleIndex() { return RULE_li; }
2554                @Override
2555                public void enterRule(ParseTreeListener listener) {
2556                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this);
2557                }
2558                @Override
2559                public void exitRule(ParseTreeListener listener) {
2560                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this);
2561                }
2562                @Override
2563                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2564                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this);
2565                        else return visitor.visitChildren(this);
2566                }
2567        }
2568
2569        public final LiContext li() throws RecognitionException {
2570                LiContext _localctx = new LiContext(_ctx, getState());
2571                enterRule(_localctx, 22, RULE_li);
2572                try {
2573                        int _alt;
2574                        enterOuterAlt(_localctx, 1);
2575                        {
2576                        setState(399);
2577                        liTagOpen();
2578                        setState(439);
2579                        _errHandler.sync(this);
2580                        _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2581                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2582                                if ( _alt==1 ) {
2583                                        {
2584                                        setState(437);
2585                                        _errHandler.sync(this);
2586                                        switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
2587                                        case 1:
2588                                                {
2589                                                setState(400);
2590                                                htmlTag();
2591                                                }
2592                                                break;
2593                                        case 2:
2594                                                {
2595                                                setState(401);
2596                                                singletonTag();
2597                                                }
2598                                                break;
2599                                        case 3:
2600                                                {
2601                                                setState(402);
2602                                                paragraph();
2603                                                }
2604                                                break;
2605                                        case 4:
2606                                                {
2607                                                setState(403);
2608                                                tr();
2609                                                }
2610                                                break;
2611                                        case 5:
2612                                                {
2613                                                setState(404);
2614                                                td();
2615                                                }
2616                                                break;
2617                                        case 6:
2618                                                {
2619                                                setState(405);
2620                                                th();
2621                                                }
2622                                                break;
2623                                        case 7:
2624                                                {
2625                                                setState(406);
2626                                                body();
2627                                                }
2628                                                break;
2629                                        case 8:
2630                                                {
2631                                                setState(407);
2632                                                colgroup();
2633                                                }
2634                                                break;
2635                                        case 9:
2636                                                {
2637                                                setState(408);
2638                                                dd();
2639                                                }
2640                                                break;
2641                                        case 10:
2642                                                {
2643                                                setState(409);
2644                                                dt();
2645                                                }
2646                                                break;
2647                                        case 11:
2648                                                {
2649                                                setState(410);
2650                                                head();
2651                                                }
2652                                                break;
2653                                        case 12:
2654                                                {
2655                                                setState(411);
2656                                                html();
2657                                                }
2658                                                break;
2659                                        case 13:
2660                                                {
2661                                                setState(412);
2662                                                option();
2663                                                }
2664                                                break;
2665                                        case 14:
2666                                                {
2667                                                setState(413);
2668                                                tbody();
2669                                                }
2670                                                break;
2671                                        case 15:
2672                                                {
2673                                                setState(414);
2674                                                thead();
2675                                                }
2676                                                break;
2677                                        case 16:
2678                                                {
2679                                                setState(415);
2680                                                tfoot();
2681                                                }
2682                                                break;
2683                                        case 17:
2684                                                {
2685                                                setState(416);
2686                                                pTagOpen();
2687                                                }
2688                                                break;
2689                                        case 18:
2690                                                {
2691                                                setState(417);
2692                                                trTagOpen();
2693                                                }
2694                                                break;
2695                                        case 19:
2696                                                {
2697                                                setState(418);
2698                                                tdTagOpen();
2699                                                }
2700                                                break;
2701                                        case 20:
2702                                                {
2703                                                setState(419);
2704                                                thTagOpen();
2705                                                }
2706                                                break;
2707                                        case 21:
2708                                                {
2709                                                setState(420);
2710                                                bodyTagOpen();
2711                                                }
2712                                                break;
2713                                        case 22:
2714                                                {
2715                                                setState(421);
2716                                                colgroupTagOpen();
2717                                                }
2718                                                break;
2719                                        case 23:
2720                                                {
2721                                                setState(422);
2722                                                ddTagOpen();
2723                                                }
2724                                                break;
2725                                        case 24:
2726                                                {
2727                                                setState(423);
2728                                                dtTagOpen();
2729                                                }
2730                                                break;
2731                                        case 25:
2732                                                {
2733                                                setState(424);
2734                                                headTagOpen();
2735                                                }
2736                                                break;
2737                                        case 26:
2738                                                {
2739                                                setState(425);
2740                                                htmlTagOpen();
2741                                                }
2742                                                break;
2743                                        case 27:
2744                                                {
2745                                                setState(426);
2746                                                optionTagOpen();
2747                                                }
2748                                                break;
2749                                        case 28:
2750                                                {
2751                                                setState(427);
2752                                                tbodyTagOpen();
2753                                                }
2754                                                break;
2755                                        case 29:
2756                                                {
2757                                                setState(428);
2758                                                theadTagOpen();
2759                                                }
2760                                                break;
2761                                        case 30:
2762                                                {
2763                                                setState(429);
2764                                                tfootTagOpen();
2765                                                }
2766                                                break;
2767                                        case 31:
2768                                                {
2769                                                {
2770                                                setState(430);
2771                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2772                                                setState(431);
2773                                                match(LEADING_ASTERISK);
2774                                                }
2775                                                }
2776                                                break;
2777                                        case 32:
2778                                                {
2779                                                setState(432);
2780                                                htmlComment();
2781                                                }
2782                                                break;
2783                                        case 33:
2784                                                {
2785                                                setState(433);
2786                                                match(CDATA);
2787                                                }
2788                                                break;
2789                                        case 34:
2790                                                {
2791                                                setState(434);
2792                                                match(NEWLINE);
2793                                                }
2794                                                break;
2795                                        case 35:
2796                                                {
2797                                                setState(435);
2798                                                text();
2799                                                }
2800                                                break;
2801                                        case 36:
2802                                                {
2803                                                setState(436);
2804                                                javadocInlineTag();
2805                                                }
2806                                                break;
2807                                        }
2808                                        } 
2809                                }
2810                                setState(441);
2811                                _errHandler.sync(this);
2812                                _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2813                        }
2814                        setState(442);
2815                        liTagClose();
2816                        }
2817                }
2818                catch (RecognitionException re) {
2819                        _localctx.exception = re;
2820                        _errHandler.reportError(this, re);
2821                        _errHandler.recover(this, re);
2822                }
2823                finally {
2824                        exitRule();
2825                }
2826                return _localctx;
2827        }
2828
2829        public static class TrTagOpenContext extends ParserRuleContext {
2830                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2831                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2832                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2833                public List<AttributeContext> attribute() {
2834                        return getRuleContexts(AttributeContext.class);
2835                }
2836                public AttributeContext attribute(int i) {
2837                        return getRuleContext(AttributeContext.class,i);
2838                }
2839                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2840                public TerminalNode NEWLINE(int i) {
2841                        return getToken(JavadocParser.NEWLINE, i);
2842                }
2843                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2844                public TerminalNode LEADING_ASTERISK(int i) {
2845                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2846                }
2847                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2848                public TerminalNode WS(int i) {
2849                        return getToken(JavadocParser.WS, i);
2850                }
2851                public TrTagOpenContext(ParserRuleContext parent, int invokingState) {
2852                        super(parent, invokingState);
2853                }
2854                @Override public int getRuleIndex() { return RULE_trTagOpen; }
2855                @Override
2856                public void enterRule(ParseTreeListener listener) {
2857                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this);
2858                }
2859                @Override
2860                public void exitRule(ParseTreeListener listener) {
2861                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this);
2862                }
2863                @Override
2864                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2865                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this);
2866                        else return visitor.visitChildren(this);
2867                }
2868        }
2869
2870        public final TrTagOpenContext trTagOpen() throws RecognitionException {
2871                TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState());
2872                enterRule(_localctx, 24, RULE_trTagOpen);
2873                int _la;
2874                try {
2875                        enterOuterAlt(_localctx, 1);
2876                        {
2877                        setState(444);
2878                        match(OPEN);
2879                        setState(445);
2880                        match(TR_HTML_TAG_NAME);
2881                        setState(452);
2882                        _errHandler.sync(this);
2883                        _la = _input.LA(1);
2884                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2885                                {
2886                                setState(450);
2887                                _errHandler.sync(this);
2888                                switch (_input.LA(1)) {
2889                                case HTML_TAG_NAME:
2890                                        {
2891                                        setState(446);
2892                                        attribute();
2893                                        }
2894                                        break;
2895                                case NEWLINE:
2896                                        {
2897                                        setState(447);
2898                                        match(NEWLINE);
2899                                        }
2900                                        break;
2901                                case LEADING_ASTERISK:
2902                                        {
2903                                        setState(448);
2904                                        match(LEADING_ASTERISK);
2905                                        }
2906                                        break;
2907                                case WS:
2908                                        {
2909                                        setState(449);
2910                                        match(WS);
2911                                        }
2912                                        break;
2913                                default:
2914                                        throw new NoViableAltException(this);
2915                                }
2916                                }
2917                                setState(454);
2918                                _errHandler.sync(this);
2919                                _la = _input.LA(1);
2920                        }
2921                        setState(455);
2922                        match(CLOSE);
2923                        }
2924                }
2925                catch (RecognitionException re) {
2926                        _localctx.exception = re;
2927                        _errHandler.reportError(this, re);
2928                        _errHandler.recover(this, re);
2929                }
2930                finally {
2931                        exitRule();
2932                }
2933                return _localctx;
2934        }
2935
2936        public static class TrTagCloseContext extends ParserRuleContext {
2937                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2938                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2939                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2940                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2941                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2942                public TerminalNode NEWLINE(int i) {
2943                        return getToken(JavadocParser.NEWLINE, i);
2944                }
2945                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2946                public TerminalNode LEADING_ASTERISK(int i) {
2947                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2948                }
2949                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2950                public TerminalNode WS(int i) {
2951                        return getToken(JavadocParser.WS, i);
2952                }
2953                public TrTagCloseContext(ParserRuleContext parent, int invokingState) {
2954                        super(parent, invokingState);
2955                }
2956                @Override public int getRuleIndex() { return RULE_trTagClose; }
2957                @Override
2958                public void enterRule(ParseTreeListener listener) {
2959                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this);
2960                }
2961                @Override
2962                public void exitRule(ParseTreeListener listener) {
2963                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this);
2964                }
2965                @Override
2966                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2967                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this);
2968                        else return visitor.visitChildren(this);
2969                }
2970        }
2971
2972        public final TrTagCloseContext trTagClose() throws RecognitionException {
2973                TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState());
2974                enterRule(_localctx, 26, RULE_trTagClose);
2975                int _la;
2976                try {
2977                        enterOuterAlt(_localctx, 1);
2978                        {
2979                        setState(457);
2980                        match(OPEN);
2981                        setState(458);
2982                        match(SLASH);
2983                        setState(459);
2984                        match(TR_HTML_TAG_NAME);
2985                        setState(463);
2986                        _errHandler.sync(this);
2987                        _la = _input.LA(1);
2988                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2989                                {
2990                                {
2991                                setState(460);
2992                                _la = _input.LA(1);
2993                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2994                                _errHandler.recoverInline(this);
2995                                }
2996                                else {
2997                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
2998                                        _errHandler.reportMatch(this);
2999                                        consume();
3000                                }
3001                                }
3002                                }
3003                                setState(465);
3004                                _errHandler.sync(this);
3005                                _la = _input.LA(1);
3006                        }
3007                        setState(466);
3008                        match(CLOSE);
3009                        }
3010                }
3011                catch (RecognitionException re) {
3012                        _localctx.exception = re;
3013                        _errHandler.reportError(this, re);
3014                        _errHandler.recover(this, re);
3015                }
3016                finally {
3017                        exitRule();
3018                }
3019                return _localctx;
3020        }
3021
3022        public static class TrContext extends ParserRuleContext {
3023                public TrTagOpenContext trTagOpen() {
3024                        return getRuleContext(TrTagOpenContext.class,0);
3025                }
3026                public TrTagCloseContext trTagClose() {
3027                        return getRuleContext(TrTagCloseContext.class,0);
3028                }
3029                public List<HtmlTagContext> htmlTag() {
3030                        return getRuleContexts(HtmlTagContext.class);
3031                }
3032                public HtmlTagContext htmlTag(int i) {
3033                        return getRuleContext(HtmlTagContext.class,i);
3034                }
3035                public List<SingletonTagContext> singletonTag() {
3036                        return getRuleContexts(SingletonTagContext.class);
3037                }
3038                public SingletonTagContext singletonTag(int i) {
3039                        return getRuleContext(SingletonTagContext.class,i);
3040                }
3041                public List<ParagraphContext> paragraph() {
3042                        return getRuleContexts(ParagraphContext.class);
3043                }
3044                public ParagraphContext paragraph(int i) {
3045                        return getRuleContext(ParagraphContext.class,i);
3046                }
3047                public List<LiContext> li() {
3048                        return getRuleContexts(LiContext.class);
3049                }
3050                public LiContext li(int i) {
3051                        return getRuleContext(LiContext.class,i);
3052                }
3053                public List<TdContext> td() {
3054                        return getRuleContexts(TdContext.class);
3055                }
3056                public TdContext td(int i) {
3057                        return getRuleContext(TdContext.class,i);
3058                }
3059                public List<ThContext> th() {
3060                        return getRuleContexts(ThContext.class);
3061                }
3062                public ThContext th(int i) {
3063                        return getRuleContext(ThContext.class,i);
3064                }
3065                public List<BodyContext> body() {
3066                        return getRuleContexts(BodyContext.class);
3067                }
3068                public BodyContext body(int i) {
3069                        return getRuleContext(BodyContext.class,i);
3070                }
3071                public List<ColgroupContext> colgroup() {
3072                        return getRuleContexts(ColgroupContext.class);
3073                }
3074                public ColgroupContext colgroup(int i) {
3075                        return getRuleContext(ColgroupContext.class,i);
3076                }
3077                public List<DdContext> dd() {
3078                        return getRuleContexts(DdContext.class);
3079                }
3080                public DdContext dd(int i) {
3081                        return getRuleContext(DdContext.class,i);
3082                }
3083                public List<DtContext> dt() {
3084                        return getRuleContexts(DtContext.class);
3085                }
3086                public DtContext dt(int i) {
3087                        return getRuleContext(DtContext.class,i);
3088                }
3089                public List<HeadContext> head() {
3090                        return getRuleContexts(HeadContext.class);
3091                }
3092                public HeadContext head(int i) {
3093                        return getRuleContext(HeadContext.class,i);
3094                }
3095                public List<HtmlContext> html() {
3096                        return getRuleContexts(HtmlContext.class);
3097                }
3098                public HtmlContext html(int i) {
3099                        return getRuleContext(HtmlContext.class,i);
3100                }
3101                public List<OptionContext> option() {
3102                        return getRuleContexts(OptionContext.class);
3103                }
3104                public OptionContext option(int i) {
3105                        return getRuleContext(OptionContext.class,i);
3106                }
3107                public List<TbodyContext> tbody() {
3108                        return getRuleContexts(TbodyContext.class);
3109                }
3110                public TbodyContext tbody(int i) {
3111                        return getRuleContext(TbodyContext.class,i);
3112                }
3113                public List<TheadContext> thead() {
3114                        return getRuleContexts(TheadContext.class);
3115                }
3116                public TheadContext thead(int i) {
3117                        return getRuleContext(TheadContext.class,i);
3118                }
3119                public List<TfootContext> tfoot() {
3120                        return getRuleContexts(TfootContext.class);
3121                }
3122                public TfootContext tfoot(int i) {
3123                        return getRuleContext(TfootContext.class,i);
3124                }
3125                public List<PTagOpenContext> pTagOpen() {
3126                        return getRuleContexts(PTagOpenContext.class);
3127                }
3128                public PTagOpenContext pTagOpen(int i) {
3129                        return getRuleContext(PTagOpenContext.class,i);
3130                }
3131                public List<LiTagOpenContext> liTagOpen() {
3132                        return getRuleContexts(LiTagOpenContext.class);
3133                }
3134                public LiTagOpenContext liTagOpen(int i) {
3135                        return getRuleContext(LiTagOpenContext.class,i);
3136                }
3137                public List<TdTagOpenContext> tdTagOpen() {
3138                        return getRuleContexts(TdTagOpenContext.class);
3139                }
3140                public TdTagOpenContext tdTagOpen(int i) {
3141                        return getRuleContext(TdTagOpenContext.class,i);
3142                }
3143                public List<ThTagOpenContext> thTagOpen() {
3144                        return getRuleContexts(ThTagOpenContext.class);
3145                }
3146                public ThTagOpenContext thTagOpen(int i) {
3147                        return getRuleContext(ThTagOpenContext.class,i);
3148                }
3149                public List<BodyTagOpenContext> bodyTagOpen() {
3150                        return getRuleContexts(BodyTagOpenContext.class);
3151                }
3152                public BodyTagOpenContext bodyTagOpen(int i) {
3153                        return getRuleContext(BodyTagOpenContext.class,i);
3154                }
3155                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3156                        return getRuleContexts(ColgroupTagOpenContext.class);
3157                }
3158                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3159                        return getRuleContext(ColgroupTagOpenContext.class,i);
3160                }
3161                public List<DdTagOpenContext> ddTagOpen() {
3162                        return getRuleContexts(DdTagOpenContext.class);
3163                }
3164                public DdTagOpenContext ddTagOpen(int i) {
3165                        return getRuleContext(DdTagOpenContext.class,i);
3166                }
3167                public List<DtTagOpenContext> dtTagOpen() {
3168                        return getRuleContexts(DtTagOpenContext.class);
3169                }
3170                public DtTagOpenContext dtTagOpen(int i) {
3171                        return getRuleContext(DtTagOpenContext.class,i);
3172                }
3173                public List<HeadTagOpenContext> headTagOpen() {
3174                        return getRuleContexts(HeadTagOpenContext.class);
3175                }
3176                public HeadTagOpenContext headTagOpen(int i) {
3177                        return getRuleContext(HeadTagOpenContext.class,i);
3178                }
3179                public List<HtmlTagOpenContext> htmlTagOpen() {
3180                        return getRuleContexts(HtmlTagOpenContext.class);
3181                }
3182                public HtmlTagOpenContext htmlTagOpen(int i) {
3183                        return getRuleContext(HtmlTagOpenContext.class,i);
3184                }
3185                public List<OptionTagOpenContext> optionTagOpen() {
3186                        return getRuleContexts(OptionTagOpenContext.class);
3187                }
3188                public OptionTagOpenContext optionTagOpen(int i) {
3189                        return getRuleContext(OptionTagOpenContext.class,i);
3190                }
3191                public List<TbodyTagOpenContext> tbodyTagOpen() {
3192                        return getRuleContexts(TbodyTagOpenContext.class);
3193                }
3194                public TbodyTagOpenContext tbodyTagOpen(int i) {
3195                        return getRuleContext(TbodyTagOpenContext.class,i);
3196                }
3197                public List<TheadTagOpenContext> theadTagOpen() {
3198                        return getRuleContexts(TheadTagOpenContext.class);
3199                }
3200                public TheadTagOpenContext theadTagOpen(int i) {
3201                        return getRuleContext(TheadTagOpenContext.class,i);
3202                }
3203                public List<TfootTagOpenContext> tfootTagOpen() {
3204                        return getRuleContexts(TfootTagOpenContext.class);
3205                }
3206                public TfootTagOpenContext tfootTagOpen(int i) {
3207                        return getRuleContext(TfootTagOpenContext.class,i);
3208                }
3209                public List<HtmlCommentContext> htmlComment() {
3210                        return getRuleContexts(HtmlCommentContext.class);
3211                }
3212                public HtmlCommentContext htmlComment(int i) {
3213                        return getRuleContext(HtmlCommentContext.class,i);
3214                }
3215                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3216                public TerminalNode CDATA(int i) {
3217                        return getToken(JavadocParser.CDATA, i);
3218                }
3219                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3220                public TerminalNode NEWLINE(int i) {
3221                        return getToken(JavadocParser.NEWLINE, i);
3222                }
3223                public List<TextContext> text() {
3224                        return getRuleContexts(TextContext.class);
3225                }
3226                public TextContext text(int i) {
3227                        return getRuleContext(TextContext.class,i);
3228                }
3229                public List<JavadocInlineTagContext> javadocInlineTag() {
3230                        return getRuleContexts(JavadocInlineTagContext.class);
3231                }
3232                public JavadocInlineTagContext javadocInlineTag(int i) {
3233                        return getRuleContext(JavadocInlineTagContext.class,i);
3234                }
3235                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3236                public TerminalNode LEADING_ASTERISK(int i) {
3237                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3238                }
3239                public TrContext(ParserRuleContext parent, int invokingState) {
3240                        super(parent, invokingState);
3241                }
3242                @Override public int getRuleIndex() { return RULE_tr; }
3243                @Override
3244                public void enterRule(ParseTreeListener listener) {
3245                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this);
3246                }
3247                @Override
3248                public void exitRule(ParseTreeListener listener) {
3249                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this);
3250                }
3251                @Override
3252                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3253                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this);
3254                        else return visitor.visitChildren(this);
3255                }
3256        }
3257
3258        public final TrContext tr() throws RecognitionException {
3259                TrContext _localctx = new TrContext(_ctx, getState());
3260                enterRule(_localctx, 28, RULE_tr);
3261                try {
3262                        int _alt;
3263                        enterOuterAlt(_localctx, 1);
3264                        {
3265                        setState(468);
3266                        trTagOpen();
3267                        setState(508);
3268                        _errHandler.sync(this);
3269                        _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3270                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3271                                if ( _alt==1 ) {
3272                                        {
3273                                        setState(506);
3274                                        _errHandler.sync(this);
3275                                        switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
3276                                        case 1:
3277                                                {
3278                                                setState(469);
3279                                                htmlTag();
3280                                                }
3281                                                break;
3282                                        case 2:
3283                                                {
3284                                                setState(470);
3285                                                singletonTag();
3286                                                }
3287                                                break;
3288                                        case 3:
3289                                                {
3290                                                setState(471);
3291                                                paragraph();
3292                                                }
3293                                                break;
3294                                        case 4:
3295                                                {
3296                                                setState(472);
3297                                                li();
3298                                                }
3299                                                break;
3300                                        case 5:
3301                                                {
3302                                                setState(473);
3303                                                td();
3304                                                }
3305                                                break;
3306                                        case 6:
3307                                                {
3308                                                setState(474);
3309                                                th();
3310                                                }
3311                                                break;
3312                                        case 7:
3313                                                {
3314                                                setState(475);
3315                                                body();
3316                                                }
3317                                                break;
3318                                        case 8:
3319                                                {
3320                                                setState(476);
3321                                                colgroup();
3322                                                }
3323                                                break;
3324                                        case 9:
3325                                                {
3326                                                setState(477);
3327                                                dd();
3328                                                }
3329                                                break;
3330                                        case 10:
3331                                                {
3332                                                setState(478);
3333                                                dt();
3334                                                }
3335                                                break;
3336                                        case 11:
3337                                                {
3338                                                setState(479);
3339                                                head();
3340                                                }
3341                                                break;
3342                                        case 12:
3343                                                {
3344                                                setState(480);
3345                                                html();
3346                                                }
3347                                                break;
3348                                        case 13:
3349                                                {
3350                                                setState(481);
3351                                                option();
3352                                                }
3353                                                break;
3354                                        case 14:
3355                                                {
3356                                                setState(482);
3357                                                tbody();
3358                                                }
3359                                                break;
3360                                        case 15:
3361                                                {
3362                                                setState(483);
3363                                                thead();
3364                                                }
3365                                                break;
3366                                        case 16:
3367                                                {
3368                                                setState(484);
3369                                                tfoot();
3370                                                }
3371                                                break;
3372                                        case 17:
3373                                                {
3374                                                setState(485);
3375                                                pTagOpen();
3376                                                }
3377                                                break;
3378                                        case 18:
3379                                                {
3380                                                setState(486);
3381                                                liTagOpen();
3382                                                }
3383                                                break;
3384                                        case 19:
3385                                                {
3386                                                setState(487);
3387                                                tdTagOpen();
3388                                                }
3389                                                break;
3390                                        case 20:
3391                                                {
3392                                                setState(488);
3393                                                thTagOpen();
3394                                                }
3395                                                break;
3396                                        case 21:
3397                                                {
3398                                                setState(489);
3399                                                bodyTagOpen();
3400                                                }
3401                                                break;
3402                                        case 22:
3403                                                {
3404                                                setState(490);
3405                                                colgroupTagOpen();
3406                                                }
3407                                                break;
3408                                        case 23:
3409                                                {
3410                                                setState(491);
3411                                                ddTagOpen();
3412                                                }
3413                                                break;
3414                                        case 24:
3415                                                {
3416                                                setState(492);
3417                                                dtTagOpen();
3418                                                }
3419                                                break;
3420                                        case 25:
3421                                                {
3422                                                setState(493);
3423                                                headTagOpen();
3424                                                }
3425                                                break;
3426                                        case 26:
3427                                                {
3428                                                setState(494);
3429                                                htmlTagOpen();
3430                                                }
3431                                                break;
3432                                        case 27:
3433                                                {
3434                                                setState(495);
3435                                                optionTagOpen();
3436                                                }
3437                                                break;
3438                                        case 28:
3439                                                {
3440                                                setState(496);
3441                                                tbodyTagOpen();
3442                                                }
3443                                                break;
3444                                        case 29:
3445                                                {
3446                                                setState(497);
3447                                                theadTagOpen();
3448                                                }
3449                                                break;
3450                                        case 30:
3451                                                {
3452                                                setState(498);
3453                                                tfootTagOpen();
3454                                                }
3455                                                break;
3456                                        case 31:
3457                                                {
3458                                                {
3459                                                setState(499);
3460                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3461                                                setState(500);
3462                                                match(LEADING_ASTERISK);
3463                                                }
3464                                                }
3465                                                break;
3466                                        case 32:
3467                                                {
3468                                                setState(501);
3469                                                htmlComment();
3470                                                }
3471                                                break;
3472                                        case 33:
3473                                                {
3474                                                setState(502);
3475                                                match(CDATA);
3476                                                }
3477                                                break;
3478                                        case 34:
3479                                                {
3480                                                setState(503);
3481                                                match(NEWLINE);
3482                                                }
3483                                                break;
3484                                        case 35:
3485                                                {
3486                                                setState(504);
3487                                                text();
3488                                                }
3489                                                break;
3490                                        case 36:
3491                                                {
3492                                                setState(505);
3493                                                javadocInlineTag();
3494                                                }
3495                                                break;
3496                                        }
3497                                        } 
3498                                }
3499                                setState(510);
3500                                _errHandler.sync(this);
3501                                _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3502                        }
3503                        setState(511);
3504                        trTagClose();
3505                        }
3506                }
3507                catch (RecognitionException re) {
3508                        _localctx.exception = re;
3509                        _errHandler.reportError(this, re);
3510                        _errHandler.recover(this, re);
3511                }
3512                finally {
3513                        exitRule();
3514                }
3515                return _localctx;
3516        }
3517
3518        public static class TdTagOpenContext extends ParserRuleContext {
3519                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3520                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3521                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3522                public List<AttributeContext> attribute() {
3523                        return getRuleContexts(AttributeContext.class);
3524                }
3525                public AttributeContext attribute(int i) {
3526                        return getRuleContext(AttributeContext.class,i);
3527                }
3528                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3529                public TerminalNode NEWLINE(int i) {
3530                        return getToken(JavadocParser.NEWLINE, i);
3531                }
3532                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3533                public TerminalNode LEADING_ASTERISK(int i) {
3534                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3535                }
3536                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3537                public TerminalNode WS(int i) {
3538                        return getToken(JavadocParser.WS, i);
3539                }
3540                public TdTagOpenContext(ParserRuleContext parent, int invokingState) {
3541                        super(parent, invokingState);
3542                }
3543                @Override public int getRuleIndex() { return RULE_tdTagOpen; }
3544                @Override
3545                public void enterRule(ParseTreeListener listener) {
3546                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this);
3547                }
3548                @Override
3549                public void exitRule(ParseTreeListener listener) {
3550                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this);
3551                }
3552                @Override
3553                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3554                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this);
3555                        else return visitor.visitChildren(this);
3556                }
3557        }
3558
3559        public final TdTagOpenContext tdTagOpen() throws RecognitionException {
3560                TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState());
3561                enterRule(_localctx, 30, RULE_tdTagOpen);
3562                int _la;
3563                try {
3564                        enterOuterAlt(_localctx, 1);
3565                        {
3566                        setState(513);
3567                        match(OPEN);
3568                        setState(514);
3569                        match(TD_HTML_TAG_NAME);
3570                        setState(521);
3571                        _errHandler.sync(this);
3572                        _la = _input.LA(1);
3573                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3574                                {
3575                                setState(519);
3576                                _errHandler.sync(this);
3577                                switch (_input.LA(1)) {
3578                                case HTML_TAG_NAME:
3579                                        {
3580                                        setState(515);
3581                                        attribute();
3582                                        }
3583                                        break;
3584                                case NEWLINE:
3585                                        {
3586                                        setState(516);
3587                                        match(NEWLINE);
3588                                        }
3589                                        break;
3590                                case LEADING_ASTERISK:
3591                                        {
3592                                        setState(517);
3593                                        match(LEADING_ASTERISK);
3594                                        }
3595                                        break;
3596                                case WS:
3597                                        {
3598                                        setState(518);
3599                                        match(WS);
3600                                        }
3601                                        break;
3602                                default:
3603                                        throw new NoViableAltException(this);
3604                                }
3605                                }
3606                                setState(523);
3607                                _errHandler.sync(this);
3608                                _la = _input.LA(1);
3609                        }
3610                        setState(524);
3611                        match(CLOSE);
3612                        }
3613                }
3614                catch (RecognitionException re) {
3615                        _localctx.exception = re;
3616                        _errHandler.reportError(this, re);
3617                        _errHandler.recover(this, re);
3618                }
3619                finally {
3620                        exitRule();
3621                }
3622                return _localctx;
3623        }
3624
3625        public static class TdTagCloseContext extends ParserRuleContext {
3626                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3627                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3628                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3629                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3630                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3631                public TerminalNode NEWLINE(int i) {
3632                        return getToken(JavadocParser.NEWLINE, i);
3633                }
3634                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3635                public TerminalNode LEADING_ASTERISK(int i) {
3636                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3637                }
3638                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3639                public TerminalNode WS(int i) {
3640                        return getToken(JavadocParser.WS, i);
3641                }
3642                public TdTagCloseContext(ParserRuleContext parent, int invokingState) {
3643                        super(parent, invokingState);
3644                }
3645                @Override public int getRuleIndex() { return RULE_tdTagClose; }
3646                @Override
3647                public void enterRule(ParseTreeListener listener) {
3648                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this);
3649                }
3650                @Override
3651                public void exitRule(ParseTreeListener listener) {
3652                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this);
3653                }
3654                @Override
3655                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3656                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this);
3657                        else return visitor.visitChildren(this);
3658                }
3659        }
3660
3661        public final TdTagCloseContext tdTagClose() throws RecognitionException {
3662                TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState());
3663                enterRule(_localctx, 32, RULE_tdTagClose);
3664                int _la;
3665                try {
3666                        enterOuterAlt(_localctx, 1);
3667                        {
3668                        setState(526);
3669                        match(OPEN);
3670                        setState(527);
3671                        match(SLASH);
3672                        setState(528);
3673                        match(TD_HTML_TAG_NAME);
3674                        setState(532);
3675                        _errHandler.sync(this);
3676                        _la = _input.LA(1);
3677                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3678                                {
3679                                {
3680                                setState(529);
3681                                _la = _input.LA(1);
3682                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3683                                _errHandler.recoverInline(this);
3684                                }
3685                                else {
3686                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
3687                                        _errHandler.reportMatch(this);
3688                                        consume();
3689                                }
3690                                }
3691                                }
3692                                setState(534);
3693                                _errHandler.sync(this);
3694                                _la = _input.LA(1);
3695                        }
3696                        setState(535);
3697                        match(CLOSE);
3698                        }
3699                }
3700                catch (RecognitionException re) {
3701                        _localctx.exception = re;
3702                        _errHandler.reportError(this, re);
3703                        _errHandler.recover(this, re);
3704                }
3705                finally {
3706                        exitRule();
3707                }
3708                return _localctx;
3709        }
3710
3711        public static class TdContext extends ParserRuleContext {
3712                public List<TdTagOpenContext> tdTagOpen() {
3713                        return getRuleContexts(TdTagOpenContext.class);
3714                }
3715                public TdTagOpenContext tdTagOpen(int i) {
3716                        return getRuleContext(TdTagOpenContext.class,i);
3717                }
3718                public TdTagCloseContext tdTagClose() {
3719                        return getRuleContext(TdTagCloseContext.class,0);
3720                }
3721                public List<HtmlTagContext> htmlTag() {
3722                        return getRuleContexts(HtmlTagContext.class);
3723                }
3724                public HtmlTagContext htmlTag(int i) {
3725                        return getRuleContext(HtmlTagContext.class,i);
3726                }
3727                public List<SingletonTagContext> singletonTag() {
3728                        return getRuleContexts(SingletonTagContext.class);
3729                }
3730                public SingletonTagContext singletonTag(int i) {
3731                        return getRuleContext(SingletonTagContext.class,i);
3732                }
3733                public List<ParagraphContext> paragraph() {
3734                        return getRuleContexts(ParagraphContext.class);
3735                }
3736                public ParagraphContext paragraph(int i) {
3737                        return getRuleContext(ParagraphContext.class,i);
3738                }
3739                public List<LiContext> li() {
3740                        return getRuleContexts(LiContext.class);
3741                }
3742                public LiContext li(int i) {
3743                        return getRuleContext(LiContext.class,i);
3744                }
3745                public List<TrContext> tr() {
3746                        return getRuleContexts(TrContext.class);
3747                }
3748                public TrContext tr(int i) {
3749                        return getRuleContext(TrContext.class,i);
3750                }
3751                public List<ThContext> th() {
3752                        return getRuleContexts(ThContext.class);
3753                }
3754                public ThContext th(int i) {
3755                        return getRuleContext(ThContext.class,i);
3756                }
3757                public List<BodyContext> body() {
3758                        return getRuleContexts(BodyContext.class);
3759                }
3760                public BodyContext body(int i) {
3761                        return getRuleContext(BodyContext.class,i);
3762                }
3763                public List<ColgroupContext> colgroup() {
3764                        return getRuleContexts(ColgroupContext.class);
3765                }
3766                public ColgroupContext colgroup(int i) {
3767                        return getRuleContext(ColgroupContext.class,i);
3768                }
3769                public List<DdContext> dd() {
3770                        return getRuleContexts(DdContext.class);
3771                }
3772                public DdContext dd(int i) {
3773                        return getRuleContext(DdContext.class,i);
3774                }
3775                public List<DtContext> dt() {
3776                        return getRuleContexts(DtContext.class);
3777                }
3778                public DtContext dt(int i) {
3779                        return getRuleContext(DtContext.class,i);
3780                }
3781                public List<HeadContext> head() {
3782                        return getRuleContexts(HeadContext.class);
3783                }
3784                public HeadContext head(int i) {
3785                        return getRuleContext(HeadContext.class,i);
3786                }
3787                public List<HtmlContext> html() {
3788                        return getRuleContexts(HtmlContext.class);
3789                }
3790                public HtmlContext html(int i) {
3791                        return getRuleContext(HtmlContext.class,i);
3792                }
3793                public List<OptionContext> option() {
3794                        return getRuleContexts(OptionContext.class);
3795                }
3796                public OptionContext option(int i) {
3797                        return getRuleContext(OptionContext.class,i);
3798                }
3799                public List<TbodyContext> tbody() {
3800                        return getRuleContexts(TbodyContext.class);
3801                }
3802                public TbodyContext tbody(int i) {
3803                        return getRuleContext(TbodyContext.class,i);
3804                }
3805                public List<TheadContext> thead() {
3806                        return getRuleContexts(TheadContext.class);
3807                }
3808                public TheadContext thead(int i) {
3809                        return getRuleContext(TheadContext.class,i);
3810                }
3811                public List<TfootContext> tfoot() {
3812                        return getRuleContexts(TfootContext.class);
3813                }
3814                public TfootContext tfoot(int i) {
3815                        return getRuleContext(TfootContext.class,i);
3816                }
3817                public List<PTagOpenContext> pTagOpen() {
3818                        return getRuleContexts(PTagOpenContext.class);
3819                }
3820                public PTagOpenContext pTagOpen(int i) {
3821                        return getRuleContext(PTagOpenContext.class,i);
3822                }
3823                public List<LiTagOpenContext> liTagOpen() {
3824                        return getRuleContexts(LiTagOpenContext.class);
3825                }
3826                public LiTagOpenContext liTagOpen(int i) {
3827                        return getRuleContext(LiTagOpenContext.class,i);
3828                }
3829                public List<ThTagOpenContext> thTagOpen() {
3830                        return getRuleContexts(ThTagOpenContext.class);
3831                }
3832                public ThTagOpenContext thTagOpen(int i) {
3833                        return getRuleContext(ThTagOpenContext.class,i);
3834                }
3835                public List<BodyTagOpenContext> bodyTagOpen() {
3836                        return getRuleContexts(BodyTagOpenContext.class);
3837                }
3838                public BodyTagOpenContext bodyTagOpen(int i) {
3839                        return getRuleContext(BodyTagOpenContext.class,i);
3840                }
3841                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3842                        return getRuleContexts(ColgroupTagOpenContext.class);
3843                }
3844                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3845                        return getRuleContext(ColgroupTagOpenContext.class,i);
3846                }
3847                public List<DdTagOpenContext> ddTagOpen() {
3848                        return getRuleContexts(DdTagOpenContext.class);
3849                }
3850                public DdTagOpenContext ddTagOpen(int i) {
3851                        return getRuleContext(DdTagOpenContext.class,i);
3852                }
3853                public List<DtTagOpenContext> dtTagOpen() {
3854                        return getRuleContexts(DtTagOpenContext.class);
3855                }
3856                public DtTagOpenContext dtTagOpen(int i) {
3857                        return getRuleContext(DtTagOpenContext.class,i);
3858                }
3859                public List<HeadTagOpenContext> headTagOpen() {
3860                        return getRuleContexts(HeadTagOpenContext.class);
3861                }
3862                public HeadTagOpenContext headTagOpen(int i) {
3863                        return getRuleContext(HeadTagOpenContext.class,i);
3864                }
3865                public List<HtmlTagOpenContext> htmlTagOpen() {
3866                        return getRuleContexts(HtmlTagOpenContext.class);
3867                }
3868                public HtmlTagOpenContext htmlTagOpen(int i) {
3869                        return getRuleContext(HtmlTagOpenContext.class,i);
3870                }
3871                public List<OptionTagOpenContext> optionTagOpen() {
3872                        return getRuleContexts(OptionTagOpenContext.class);
3873                }
3874                public OptionTagOpenContext optionTagOpen(int i) {
3875                        return getRuleContext(OptionTagOpenContext.class,i);
3876                }
3877                public List<TbodyTagOpenContext> tbodyTagOpen() {
3878                        return getRuleContexts(TbodyTagOpenContext.class);
3879                }
3880                public TbodyTagOpenContext tbodyTagOpen(int i) {
3881                        return getRuleContext(TbodyTagOpenContext.class,i);
3882                }
3883                public List<TheadTagOpenContext> theadTagOpen() {
3884                        return getRuleContexts(TheadTagOpenContext.class);
3885                }
3886                public TheadTagOpenContext theadTagOpen(int i) {
3887                        return getRuleContext(TheadTagOpenContext.class,i);
3888                }
3889                public List<TfootTagOpenContext> tfootTagOpen() {
3890                        return getRuleContexts(TfootTagOpenContext.class);
3891                }
3892                public TfootTagOpenContext tfootTagOpen(int i) {
3893                        return getRuleContext(TfootTagOpenContext.class,i);
3894                }
3895                public List<HtmlCommentContext> htmlComment() {
3896                        return getRuleContexts(HtmlCommentContext.class);
3897                }
3898                public HtmlCommentContext htmlComment(int i) {
3899                        return getRuleContext(HtmlCommentContext.class,i);
3900                }
3901                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3902                public TerminalNode CDATA(int i) {
3903                        return getToken(JavadocParser.CDATA, i);
3904                }
3905                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3906                public TerminalNode NEWLINE(int i) {
3907                        return getToken(JavadocParser.NEWLINE, i);
3908                }
3909                public List<TextContext> text() {
3910                        return getRuleContexts(TextContext.class);
3911                }
3912                public TextContext text(int i) {
3913                        return getRuleContext(TextContext.class,i);
3914                }
3915                public List<JavadocInlineTagContext> javadocInlineTag() {
3916                        return getRuleContexts(JavadocInlineTagContext.class);
3917                }
3918                public JavadocInlineTagContext javadocInlineTag(int i) {
3919                        return getRuleContext(JavadocInlineTagContext.class,i);
3920                }
3921                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3922                public TerminalNode LEADING_ASTERISK(int i) {
3923                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3924                }
3925                public TdContext(ParserRuleContext parent, int invokingState) {
3926                        super(parent, invokingState);
3927                }
3928                @Override public int getRuleIndex() { return RULE_td; }
3929                @Override
3930                public void enterRule(ParseTreeListener listener) {
3931                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this);
3932                }
3933                @Override
3934                public void exitRule(ParseTreeListener listener) {
3935                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this);
3936                }
3937                @Override
3938                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3939                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this);
3940                        else return visitor.visitChildren(this);
3941                }
3942        }
3943
3944        public final TdContext td() throws RecognitionException {
3945                TdContext _localctx = new TdContext(_ctx, getState());
3946                enterRule(_localctx, 34, RULE_td);
3947                try {
3948                        int _alt;
3949                        enterOuterAlt(_localctx, 1);
3950                        {
3951                        setState(537);
3952                        tdTagOpen();
3953                        setState(577);
3954                        _errHandler.sync(this);
3955                        _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
3956                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3957                                if ( _alt==1 ) {
3958                                        {
3959                                        setState(575);
3960                                        _errHandler.sync(this);
3961                                        switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
3962                                        case 1:
3963                                                {
3964                                                setState(538);
3965                                                htmlTag();
3966                                                }
3967                                                break;
3968                                        case 2:
3969                                                {
3970                                                setState(539);
3971                                                singletonTag();
3972                                                }
3973                                                break;
3974                                        case 3:
3975                                                {
3976                                                setState(540);
3977                                                paragraph();
3978                                                }
3979                                                break;
3980                                        case 4:
3981                                                {
3982                                                setState(541);
3983                                                li();
3984                                                }
3985                                                break;
3986                                        case 5:
3987                                                {
3988                                                setState(542);
3989                                                tr();
3990                                                }
3991                                                break;
3992                                        case 6:
3993                                                {
3994                                                setState(543);
3995                                                th();
3996                                                }
3997                                                break;
3998                                        case 7:
3999                                                {
4000                                                setState(544);
4001                                                body();
4002                                                }
4003                                                break;
4004                                        case 8:
4005                                                {
4006                                                setState(545);
4007                                                colgroup();
4008                                                }
4009                                                break;
4010                                        case 9:
4011                                                {
4012                                                setState(546);
4013                                                dd();
4014                                                }
4015                                                break;
4016                                        case 10:
4017                                                {
4018                                                setState(547);
4019                                                dt();
4020                                                }
4021                                                break;
4022                                        case 11:
4023                                                {
4024                                                setState(548);
4025                                                head();
4026                                                }
4027                                                break;
4028                                        case 12:
4029                                                {
4030                                                setState(549);
4031                                                html();
4032                                                }
4033                                                break;
4034                                        case 13:
4035                                                {
4036                                                setState(550);
4037                                                option();
4038                                                }
4039                                                break;
4040                                        case 14:
4041                                                {
4042                                                setState(551);
4043                                                tbody();
4044                                                }
4045                                                break;
4046                                        case 15:
4047                                                {
4048                                                setState(552);
4049                                                thead();
4050                                                }
4051                                                break;
4052                                        case 16:
4053                                                {
4054                                                setState(553);
4055                                                tfoot();
4056                                                }
4057                                                break;
4058                                        case 17:
4059                                                {
4060                                                setState(554);
4061                                                pTagOpen();
4062                                                }
4063                                                break;
4064                                        case 18:
4065                                                {
4066                                                setState(555);
4067                                                liTagOpen();
4068                                                }
4069                                                break;
4070                                        case 19:
4071                                                {
4072                                                setState(556);
4073                                                tdTagOpen();
4074                                                }
4075                                                break;
4076                                        case 20:
4077                                                {
4078                                                setState(557);
4079                                                thTagOpen();
4080                                                }
4081                                                break;
4082                                        case 21:
4083                                                {
4084                                                setState(558);
4085                                                bodyTagOpen();
4086                                                }
4087                                                break;
4088                                        case 22:
4089                                                {
4090                                                setState(559);
4091                                                colgroupTagOpen();
4092                                                }
4093                                                break;
4094                                        case 23:
4095                                                {
4096                                                setState(560);
4097                                                ddTagOpen();
4098                                                }
4099                                                break;
4100                                        case 24:
4101                                                {
4102                                                setState(561);
4103                                                dtTagOpen();
4104                                                }
4105                                                break;
4106                                        case 25:
4107                                                {
4108                                                setState(562);
4109                                                headTagOpen();
4110                                                }
4111                                                break;
4112                                        case 26:
4113                                                {
4114                                                setState(563);
4115                                                htmlTagOpen();
4116                                                }
4117                                                break;
4118                                        case 27:
4119                                                {
4120                                                setState(564);
4121                                                optionTagOpen();
4122                                                }
4123                                                break;
4124                                        case 28:
4125                                                {
4126                                                setState(565);
4127                                                tbodyTagOpen();
4128                                                }
4129                                                break;
4130                                        case 29:
4131                                                {
4132                                                setState(566);
4133                                                theadTagOpen();
4134                                                }
4135                                                break;
4136                                        case 30:
4137                                                {
4138                                                setState(567);
4139                                                tfootTagOpen();
4140                                                }
4141                                                break;
4142                                        case 31:
4143                                                {
4144                                                {
4145                                                setState(568);
4146                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4147                                                setState(569);
4148                                                match(LEADING_ASTERISK);
4149                                                }
4150                                                }
4151                                                break;
4152                                        case 32:
4153                                                {
4154                                                setState(570);
4155                                                htmlComment();
4156                                                }
4157                                                break;
4158                                        case 33:
4159                                                {
4160                                                setState(571);
4161                                                match(CDATA);
4162                                                }
4163                                                break;
4164                                        case 34:
4165                                                {
4166                                                setState(572);
4167                                                match(NEWLINE);
4168                                                }
4169                                                break;
4170                                        case 35:
4171                                                {
4172                                                setState(573);
4173                                                text();
4174                                                }
4175                                                break;
4176                                        case 36:
4177                                                {
4178                                                setState(574);
4179                                                javadocInlineTag();
4180                                                }
4181                                                break;
4182                                        }
4183                                        } 
4184                                }
4185                                setState(579);
4186                                _errHandler.sync(this);
4187                                _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
4188                        }
4189                        setState(580);
4190                        tdTagClose();
4191                        }
4192                }
4193                catch (RecognitionException re) {
4194                        _localctx.exception = re;
4195                        _errHandler.reportError(this, re);
4196                        _errHandler.recover(this, re);
4197                }
4198                finally {
4199                        exitRule();
4200                }
4201                return _localctx;
4202        }
4203
4204        public static class ThTagOpenContext extends ParserRuleContext {
4205                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4206                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4207                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4208                public List<AttributeContext> attribute() {
4209                        return getRuleContexts(AttributeContext.class);
4210                }
4211                public AttributeContext attribute(int i) {
4212                        return getRuleContext(AttributeContext.class,i);
4213                }
4214                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4215                public TerminalNode NEWLINE(int i) {
4216                        return getToken(JavadocParser.NEWLINE, i);
4217                }
4218                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4219                public TerminalNode LEADING_ASTERISK(int i) {
4220                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4221                }
4222                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4223                public TerminalNode WS(int i) {
4224                        return getToken(JavadocParser.WS, i);
4225                }
4226                public ThTagOpenContext(ParserRuleContext parent, int invokingState) {
4227                        super(parent, invokingState);
4228                }
4229                @Override public int getRuleIndex() { return RULE_thTagOpen; }
4230                @Override
4231                public void enterRule(ParseTreeListener listener) {
4232                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this);
4233                }
4234                @Override
4235                public void exitRule(ParseTreeListener listener) {
4236                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this);
4237                }
4238                @Override
4239                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4240                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this);
4241                        else return visitor.visitChildren(this);
4242                }
4243        }
4244
4245        public final ThTagOpenContext thTagOpen() throws RecognitionException {
4246                ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState());
4247                enterRule(_localctx, 36, RULE_thTagOpen);
4248                int _la;
4249                try {
4250                        enterOuterAlt(_localctx, 1);
4251                        {
4252                        setState(582);
4253                        match(OPEN);
4254                        setState(583);
4255                        match(TH_HTML_TAG_NAME);
4256                        setState(590);
4257                        _errHandler.sync(this);
4258                        _la = _input.LA(1);
4259                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4260                                {
4261                                setState(588);
4262                                _errHandler.sync(this);
4263                                switch (_input.LA(1)) {
4264                                case HTML_TAG_NAME:
4265                                        {
4266                                        setState(584);
4267                                        attribute();
4268                                        }
4269                                        break;
4270                                case NEWLINE:
4271                                        {
4272                                        setState(585);
4273                                        match(NEWLINE);
4274                                        }
4275                                        break;
4276                                case LEADING_ASTERISK:
4277                                        {
4278                                        setState(586);
4279                                        match(LEADING_ASTERISK);
4280                                        }
4281                                        break;
4282                                case WS:
4283                                        {
4284                                        setState(587);
4285                                        match(WS);
4286                                        }
4287                                        break;
4288                                default:
4289                                        throw new NoViableAltException(this);
4290                                }
4291                                }
4292                                setState(592);
4293                                _errHandler.sync(this);
4294                                _la = _input.LA(1);
4295                        }
4296                        setState(593);
4297                        match(CLOSE);
4298                        }
4299                }
4300                catch (RecognitionException re) {
4301                        _localctx.exception = re;
4302                        _errHandler.reportError(this, re);
4303                        _errHandler.recover(this, re);
4304                }
4305                finally {
4306                        exitRule();
4307                }
4308                return _localctx;
4309        }
4310
4311        public static class ThTagCloseContext extends ParserRuleContext {
4312                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4313                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4314                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4315                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4316                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4317                public TerminalNode NEWLINE(int i) {
4318                        return getToken(JavadocParser.NEWLINE, i);
4319                }
4320                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4321                public TerminalNode LEADING_ASTERISK(int i) {
4322                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4323                }
4324                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4325                public TerminalNode WS(int i) {
4326                        return getToken(JavadocParser.WS, i);
4327                }
4328                public ThTagCloseContext(ParserRuleContext parent, int invokingState) {
4329                        super(parent, invokingState);
4330                }
4331                @Override public int getRuleIndex() { return RULE_thTagClose; }
4332                @Override
4333                public void enterRule(ParseTreeListener listener) {
4334                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this);
4335                }
4336                @Override
4337                public void exitRule(ParseTreeListener listener) {
4338                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this);
4339                }
4340                @Override
4341                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4342                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this);
4343                        else return visitor.visitChildren(this);
4344                }
4345        }
4346
4347        public final ThTagCloseContext thTagClose() throws RecognitionException {
4348                ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState());
4349                enterRule(_localctx, 38, RULE_thTagClose);
4350                int _la;
4351                try {
4352                        enterOuterAlt(_localctx, 1);
4353                        {
4354                        setState(595);
4355                        match(OPEN);
4356                        setState(596);
4357                        match(SLASH);
4358                        setState(597);
4359                        match(TH_HTML_TAG_NAME);
4360                        setState(601);
4361                        _errHandler.sync(this);
4362                        _la = _input.LA(1);
4363                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4364                                {
4365                                {
4366                                setState(598);
4367                                _la = _input.LA(1);
4368                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4369                                _errHandler.recoverInline(this);
4370                                }
4371                                else {
4372                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
4373                                        _errHandler.reportMatch(this);
4374                                        consume();
4375                                }
4376                                }
4377                                }
4378                                setState(603);
4379                                _errHandler.sync(this);
4380                                _la = _input.LA(1);
4381                        }
4382                        setState(604);
4383                        match(CLOSE);
4384                        }
4385                }
4386                catch (RecognitionException re) {
4387                        _localctx.exception = re;
4388                        _errHandler.reportError(this, re);
4389                        _errHandler.recover(this, re);
4390                }
4391                finally {
4392                        exitRule();
4393                }
4394                return _localctx;
4395        }
4396
4397        public static class ThContext extends ParserRuleContext {
4398                public ThTagOpenContext thTagOpen() {
4399                        return getRuleContext(ThTagOpenContext.class,0);
4400                }
4401                public ThTagCloseContext thTagClose() {
4402                        return getRuleContext(ThTagCloseContext.class,0);
4403                }
4404                public List<HtmlTagContext> htmlTag() {
4405                        return getRuleContexts(HtmlTagContext.class);
4406                }
4407                public HtmlTagContext htmlTag(int i) {
4408                        return getRuleContext(HtmlTagContext.class,i);
4409                }
4410                public List<SingletonTagContext> singletonTag() {
4411                        return getRuleContexts(SingletonTagContext.class);
4412                }
4413                public SingletonTagContext singletonTag(int i) {
4414                        return getRuleContext(SingletonTagContext.class,i);
4415                }
4416                public List<ParagraphContext> paragraph() {
4417                        return getRuleContexts(ParagraphContext.class);
4418                }
4419                public ParagraphContext paragraph(int i) {
4420                        return getRuleContext(ParagraphContext.class,i);
4421                }
4422                public List<LiContext> li() {
4423                        return getRuleContexts(LiContext.class);
4424                }
4425                public LiContext li(int i) {
4426                        return getRuleContext(LiContext.class,i);
4427                }
4428                public List<TrContext> tr() {
4429                        return getRuleContexts(TrContext.class);
4430                }
4431                public TrContext tr(int i) {
4432                        return getRuleContext(TrContext.class,i);
4433                }
4434                public List<TdContext> td() {
4435                        return getRuleContexts(TdContext.class);
4436                }
4437                public TdContext td(int i) {
4438                        return getRuleContext(TdContext.class,i);
4439                }
4440                public List<BodyContext> body() {
4441                        return getRuleContexts(BodyContext.class);
4442                }
4443                public BodyContext body(int i) {
4444                        return getRuleContext(BodyContext.class,i);
4445                }
4446                public List<ColgroupContext> colgroup() {
4447                        return getRuleContexts(ColgroupContext.class);
4448                }
4449                public ColgroupContext colgroup(int i) {
4450                        return getRuleContext(ColgroupContext.class,i);
4451                }
4452                public List<DdContext> dd() {
4453                        return getRuleContexts(DdContext.class);
4454                }
4455                public DdContext dd(int i) {
4456                        return getRuleContext(DdContext.class,i);
4457                }
4458                public List<DtContext> dt() {
4459                        return getRuleContexts(DtContext.class);
4460                }
4461                public DtContext dt(int i) {
4462                        return getRuleContext(DtContext.class,i);
4463                }
4464                public List<HeadContext> head() {
4465                        return getRuleContexts(HeadContext.class);
4466                }
4467                public HeadContext head(int i) {
4468                        return getRuleContext(HeadContext.class,i);
4469                }
4470                public List<HtmlContext> html() {
4471                        return getRuleContexts(HtmlContext.class);
4472                }
4473                public HtmlContext html(int i) {
4474                        return getRuleContext(HtmlContext.class,i);
4475                }
4476                public List<OptionContext> option() {
4477                        return getRuleContexts(OptionContext.class);
4478                }
4479                public OptionContext option(int i) {
4480                        return getRuleContext(OptionContext.class,i);
4481                }
4482                public List<TbodyContext> tbody() {
4483                        return getRuleContexts(TbodyContext.class);
4484                }
4485                public TbodyContext tbody(int i) {
4486                        return getRuleContext(TbodyContext.class,i);
4487                }
4488                public List<TheadContext> thead() {
4489                        return getRuleContexts(TheadContext.class);
4490                }
4491                public TheadContext thead(int i) {
4492                        return getRuleContext(TheadContext.class,i);
4493                }
4494                public List<TfootContext> tfoot() {
4495                        return getRuleContexts(TfootContext.class);
4496                }
4497                public TfootContext tfoot(int i) {
4498                        return getRuleContext(TfootContext.class,i);
4499                }
4500                public List<PTagOpenContext> pTagOpen() {
4501                        return getRuleContexts(PTagOpenContext.class);
4502                }
4503                public PTagOpenContext pTagOpen(int i) {
4504                        return getRuleContext(PTagOpenContext.class,i);
4505                }
4506                public List<LiTagOpenContext> liTagOpen() {
4507                        return getRuleContexts(LiTagOpenContext.class);
4508                }
4509                public LiTagOpenContext liTagOpen(int i) {
4510                        return getRuleContext(LiTagOpenContext.class,i);
4511                }
4512                public List<TrTagOpenContext> trTagOpen() {
4513                        return getRuleContexts(TrTagOpenContext.class);
4514                }
4515                public TrTagOpenContext trTagOpen(int i) {
4516                        return getRuleContext(TrTagOpenContext.class,i);
4517                }
4518                public List<TdTagOpenContext> tdTagOpen() {
4519                        return getRuleContexts(TdTagOpenContext.class);
4520                }
4521                public TdTagOpenContext tdTagOpen(int i) {
4522                        return getRuleContext(TdTagOpenContext.class,i);
4523                }
4524                public List<BodyTagOpenContext> bodyTagOpen() {
4525                        return getRuleContexts(BodyTagOpenContext.class);
4526                }
4527                public BodyTagOpenContext bodyTagOpen(int i) {
4528                        return getRuleContext(BodyTagOpenContext.class,i);
4529                }
4530                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4531                        return getRuleContexts(ColgroupTagOpenContext.class);
4532                }
4533                public ColgroupTagOpenContext colgroupTagOpen(int i) {
4534                        return getRuleContext(ColgroupTagOpenContext.class,i);
4535                }
4536                public List<DdTagOpenContext> ddTagOpen() {
4537                        return getRuleContexts(DdTagOpenContext.class);
4538                }
4539                public DdTagOpenContext ddTagOpen(int i) {
4540                        return getRuleContext(DdTagOpenContext.class,i);
4541                }
4542                public List<DtTagOpenContext> dtTagOpen() {
4543                        return getRuleContexts(DtTagOpenContext.class);
4544                }
4545                public DtTagOpenContext dtTagOpen(int i) {
4546                        return getRuleContext(DtTagOpenContext.class,i);
4547                }
4548                public List<HeadTagOpenContext> headTagOpen() {
4549                        return getRuleContexts(HeadTagOpenContext.class);
4550                }
4551                public HeadTagOpenContext headTagOpen(int i) {
4552                        return getRuleContext(HeadTagOpenContext.class,i);
4553                }
4554                public List<HtmlTagOpenContext> htmlTagOpen() {
4555                        return getRuleContexts(HtmlTagOpenContext.class);
4556                }
4557                public HtmlTagOpenContext htmlTagOpen(int i) {
4558                        return getRuleContext(HtmlTagOpenContext.class,i);
4559                }
4560                public List<OptionTagOpenContext> optionTagOpen() {
4561                        return getRuleContexts(OptionTagOpenContext.class);
4562                }
4563                public OptionTagOpenContext optionTagOpen(int i) {
4564                        return getRuleContext(OptionTagOpenContext.class,i);
4565                }
4566                public List<TbodyTagOpenContext> tbodyTagOpen() {
4567                        return getRuleContexts(TbodyTagOpenContext.class);
4568                }
4569                public TbodyTagOpenContext tbodyTagOpen(int i) {
4570                        return getRuleContext(TbodyTagOpenContext.class,i);
4571                }
4572                public List<TheadTagOpenContext> theadTagOpen() {
4573                        return getRuleContexts(TheadTagOpenContext.class);
4574                }
4575                public TheadTagOpenContext theadTagOpen(int i) {
4576                        return getRuleContext(TheadTagOpenContext.class,i);
4577                }
4578                public List<TfootTagOpenContext> tfootTagOpen() {
4579                        return getRuleContexts(TfootTagOpenContext.class);
4580                }
4581                public TfootTagOpenContext tfootTagOpen(int i) {
4582                        return getRuleContext(TfootTagOpenContext.class,i);
4583                }
4584                public List<HtmlCommentContext> htmlComment() {
4585                        return getRuleContexts(HtmlCommentContext.class);
4586                }
4587                public HtmlCommentContext htmlComment(int i) {
4588                        return getRuleContext(HtmlCommentContext.class,i);
4589                }
4590                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4591                public TerminalNode CDATA(int i) {
4592                        return getToken(JavadocParser.CDATA, i);
4593                }
4594                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4595                public TerminalNode NEWLINE(int i) {
4596                        return getToken(JavadocParser.NEWLINE, i);
4597                }
4598                public List<TextContext> text() {
4599                        return getRuleContexts(TextContext.class);
4600                }
4601                public TextContext text(int i) {
4602                        return getRuleContext(TextContext.class,i);
4603                }
4604                public List<JavadocInlineTagContext> javadocInlineTag() {
4605                        return getRuleContexts(JavadocInlineTagContext.class);
4606                }
4607                public JavadocInlineTagContext javadocInlineTag(int i) {
4608                        return getRuleContext(JavadocInlineTagContext.class,i);
4609                }
4610                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4611                public TerminalNode LEADING_ASTERISK(int i) {
4612                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4613                }
4614                public ThContext(ParserRuleContext parent, int invokingState) {
4615                        super(parent, invokingState);
4616                }
4617                @Override public int getRuleIndex() { return RULE_th; }
4618                @Override
4619                public void enterRule(ParseTreeListener listener) {
4620                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this);
4621                }
4622                @Override
4623                public void exitRule(ParseTreeListener listener) {
4624                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this);
4625                }
4626                @Override
4627                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4628                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this);
4629                        else return visitor.visitChildren(this);
4630                }
4631        }
4632
4633        public final ThContext th() throws RecognitionException {
4634                ThContext _localctx = new ThContext(_ctx, getState());
4635                enterRule(_localctx, 40, RULE_th);
4636                try {
4637                        int _alt;
4638                        enterOuterAlt(_localctx, 1);
4639                        {
4640                        setState(606);
4641                        thTagOpen();
4642                        setState(646);
4643                        _errHandler.sync(this);
4644                        _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4645                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4646                                if ( _alt==1 ) {
4647                                        {
4648                                        setState(644);
4649                                        _errHandler.sync(this);
4650                                        switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
4651                                        case 1:
4652                                                {
4653                                                setState(607);
4654                                                htmlTag();
4655                                                }
4656                                                break;
4657                                        case 2:
4658                                                {
4659                                                setState(608);
4660                                                singletonTag();
4661                                                }
4662                                                break;
4663                                        case 3:
4664                                                {
4665                                                setState(609);
4666                                                paragraph();
4667                                                }
4668                                                break;
4669                                        case 4:
4670                                                {
4671                                                setState(610);
4672                                                li();
4673                                                }
4674                                                break;
4675                                        case 5:
4676                                                {
4677                                                setState(611);
4678                                                tr();
4679                                                }
4680                                                break;
4681                                        case 6:
4682                                                {
4683                                                setState(612);
4684                                                td();
4685                                                }
4686                                                break;
4687                                        case 7:
4688                                                {
4689                                                setState(613);
4690                                                body();
4691                                                }
4692                                                break;
4693                                        case 8:
4694                                                {
4695                                                setState(614);
4696                                                colgroup();
4697                                                }
4698                                                break;
4699                                        case 9:
4700                                                {
4701                                                setState(615);
4702                                                dd();
4703                                                }
4704                                                break;
4705                                        case 10:
4706                                                {
4707                                                setState(616);
4708                                                dt();
4709                                                }
4710                                                break;
4711                                        case 11:
4712                                                {
4713                                                setState(617);
4714                                                head();
4715                                                }
4716                                                break;
4717                                        case 12:
4718                                                {
4719                                                setState(618);
4720                                                html();
4721                                                }
4722                                                break;
4723                                        case 13:
4724                                                {
4725                                                setState(619);
4726                                                option();
4727                                                }
4728                                                break;
4729                                        case 14:
4730                                                {
4731                                                setState(620);
4732                                                tbody();
4733                                                }
4734                                                break;
4735                                        case 15:
4736                                                {
4737                                                setState(621);
4738                                                thead();
4739                                                }
4740                                                break;
4741                                        case 16:
4742                                                {
4743                                                setState(622);
4744                                                tfoot();
4745                                                }
4746                                                break;
4747                                        case 17:
4748                                                {
4749                                                setState(623);
4750                                                pTagOpen();
4751                                                }
4752                                                break;
4753                                        case 18:
4754                                                {
4755                                                setState(624);
4756                                                liTagOpen();
4757                                                }
4758                                                break;
4759                                        case 19:
4760                                                {
4761                                                setState(625);
4762                                                trTagOpen();
4763                                                }
4764                                                break;
4765                                        case 20:
4766                                                {
4767                                                setState(626);
4768                                                tdTagOpen();
4769                                                }
4770                                                break;
4771                                        case 21:
4772                                                {
4773                                                setState(627);
4774                                                bodyTagOpen();
4775                                                }
4776                                                break;
4777                                        case 22:
4778                                                {
4779                                                setState(628);
4780                                                colgroupTagOpen();
4781                                                }
4782                                                break;
4783                                        case 23:
4784                                                {
4785                                                setState(629);
4786                                                ddTagOpen();
4787                                                }
4788                                                break;
4789                                        case 24:
4790                                                {
4791                                                setState(630);
4792                                                dtTagOpen();
4793                                                }
4794                                                break;
4795                                        case 25:
4796                                                {
4797                                                setState(631);
4798                                                headTagOpen();
4799                                                }
4800                                                break;
4801                                        case 26:
4802                                                {
4803                                                setState(632);
4804                                                htmlTagOpen();
4805                                                }
4806                                                break;
4807                                        case 27:
4808                                                {
4809                                                setState(633);
4810                                                optionTagOpen();
4811                                                }
4812                                                break;
4813                                        case 28:
4814                                                {
4815                                                setState(634);
4816                                                tbodyTagOpen();
4817                                                }
4818                                                break;
4819                                        case 29:
4820                                                {
4821                                                setState(635);
4822                                                theadTagOpen();
4823                                                }
4824                                                break;
4825                                        case 30:
4826                                                {
4827                                                setState(636);
4828                                                tfootTagOpen();
4829                                                }
4830                                                break;
4831                                        case 31:
4832                                                {
4833                                                {
4834                                                setState(637);
4835                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4836                                                setState(638);
4837                                                match(LEADING_ASTERISK);
4838                                                }
4839                                                }
4840                                                break;
4841                                        case 32:
4842                                                {
4843                                                setState(639);
4844                                                htmlComment();
4845                                                }
4846                                                break;
4847                                        case 33:
4848                                                {
4849                                                setState(640);
4850                                                match(CDATA);
4851                                                }
4852                                                break;
4853                                        case 34:
4854                                                {
4855                                                setState(641);
4856                                                match(NEWLINE);
4857                                                }
4858                                                break;
4859                                        case 35:
4860                                                {
4861                                                setState(642);
4862                                                text();
4863                                                }
4864                                                break;
4865                                        case 36:
4866                                                {
4867                                                setState(643);
4868                                                javadocInlineTag();
4869                                                }
4870                                                break;
4871                                        }
4872                                        } 
4873                                }
4874                                setState(648);
4875                                _errHandler.sync(this);
4876                                _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4877                        }
4878                        setState(649);
4879                        thTagClose();
4880                        }
4881                }
4882                catch (RecognitionException re) {
4883                        _localctx.exception = re;
4884                        _errHandler.reportError(this, re);
4885                        _errHandler.recover(this, re);
4886                }
4887                finally {
4888                        exitRule();
4889                }
4890                return _localctx;
4891        }
4892
4893        public static class BodyTagOpenContext extends ParserRuleContext {
4894                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4895                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4896                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4897                public List<AttributeContext> attribute() {
4898                        return getRuleContexts(AttributeContext.class);
4899                }
4900                public AttributeContext attribute(int i) {
4901                        return getRuleContext(AttributeContext.class,i);
4902                }
4903                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4904                public TerminalNode NEWLINE(int i) {
4905                        return getToken(JavadocParser.NEWLINE, i);
4906                }
4907                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4908                public TerminalNode LEADING_ASTERISK(int i) {
4909                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4910                }
4911                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4912                public TerminalNode WS(int i) {
4913                        return getToken(JavadocParser.WS, i);
4914                }
4915                public BodyTagOpenContext(ParserRuleContext parent, int invokingState) {
4916                        super(parent, invokingState);
4917                }
4918                @Override public int getRuleIndex() { return RULE_bodyTagOpen; }
4919                @Override
4920                public void enterRule(ParseTreeListener listener) {
4921                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this);
4922                }
4923                @Override
4924                public void exitRule(ParseTreeListener listener) {
4925                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this);
4926                }
4927                @Override
4928                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4929                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this);
4930                        else return visitor.visitChildren(this);
4931                }
4932        }
4933
4934        public final BodyTagOpenContext bodyTagOpen() throws RecognitionException {
4935                BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState());
4936                enterRule(_localctx, 42, RULE_bodyTagOpen);
4937                int _la;
4938                try {
4939                        enterOuterAlt(_localctx, 1);
4940                        {
4941                        setState(651);
4942                        match(OPEN);
4943                        setState(652);
4944                        match(BODY_HTML_TAG_NAME);
4945                        setState(659);
4946                        _errHandler.sync(this);
4947                        _la = _input.LA(1);
4948                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4949                                {
4950                                setState(657);
4951                                _errHandler.sync(this);
4952                                switch (_input.LA(1)) {
4953                                case HTML_TAG_NAME:
4954                                        {
4955                                        setState(653);
4956                                        attribute();
4957                                        }
4958                                        break;
4959                                case NEWLINE:
4960                                        {
4961                                        setState(654);
4962                                        match(NEWLINE);
4963                                        }
4964                                        break;
4965                                case LEADING_ASTERISK:
4966                                        {
4967                                        setState(655);
4968                                        match(LEADING_ASTERISK);
4969                                        }
4970                                        break;
4971                                case WS:
4972                                        {
4973                                        setState(656);
4974                                        match(WS);
4975                                        }
4976                                        break;
4977                                default:
4978                                        throw new NoViableAltException(this);
4979                                }
4980                                }
4981                                setState(661);
4982                                _errHandler.sync(this);
4983                                _la = _input.LA(1);
4984                        }
4985                        setState(662);
4986                        match(CLOSE);
4987                        }
4988                }
4989                catch (RecognitionException re) {
4990                        _localctx.exception = re;
4991                        _errHandler.reportError(this, re);
4992                        _errHandler.recover(this, re);
4993                }
4994                finally {
4995                        exitRule();
4996                }
4997                return _localctx;
4998        }
4999
5000        public static class BodyTagCloseContext extends ParserRuleContext {
5001                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5002                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5003                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
5004                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5005                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5006                public TerminalNode NEWLINE(int i) {
5007                        return getToken(JavadocParser.NEWLINE, i);
5008                }
5009                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5010                public TerminalNode LEADING_ASTERISK(int i) {
5011                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5012                }
5013                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5014                public TerminalNode WS(int i) {
5015                        return getToken(JavadocParser.WS, i);
5016                }
5017                public BodyTagCloseContext(ParserRuleContext parent, int invokingState) {
5018                        super(parent, invokingState);
5019                }
5020                @Override public int getRuleIndex() { return RULE_bodyTagClose; }
5021                @Override
5022                public void enterRule(ParseTreeListener listener) {
5023                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this);
5024                }
5025                @Override
5026                public void exitRule(ParseTreeListener listener) {
5027                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this);
5028                }
5029                @Override
5030                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5031                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this);
5032                        else return visitor.visitChildren(this);
5033                }
5034        }
5035
5036        public final BodyTagCloseContext bodyTagClose() throws RecognitionException {
5037                BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState());
5038                enterRule(_localctx, 44, RULE_bodyTagClose);
5039                int _la;
5040                try {
5041                        enterOuterAlt(_localctx, 1);
5042                        {
5043                        setState(664);
5044                        match(OPEN);
5045                        setState(665);
5046                        match(SLASH);
5047                        setState(666);
5048                        match(BODY_HTML_TAG_NAME);
5049                        setState(670);
5050                        _errHandler.sync(this);
5051                        _la = _input.LA(1);
5052                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5053                                {
5054                                {
5055                                setState(667);
5056                                _la = _input.LA(1);
5057                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5058                                _errHandler.recoverInline(this);
5059                                }
5060                                else {
5061                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
5062                                        _errHandler.reportMatch(this);
5063                                        consume();
5064                                }
5065                                }
5066                                }
5067                                setState(672);
5068                                _errHandler.sync(this);
5069                                _la = _input.LA(1);
5070                        }
5071                        setState(673);
5072                        match(CLOSE);
5073                        }
5074                }
5075                catch (RecognitionException re) {
5076                        _localctx.exception = re;
5077                        _errHandler.reportError(this, re);
5078                        _errHandler.recover(this, re);
5079                }
5080                finally {
5081                        exitRule();
5082                }
5083                return _localctx;
5084        }
5085
5086        public static class BodyContext extends ParserRuleContext {
5087                public BodyTagOpenContext bodyTagOpen() {
5088                        return getRuleContext(BodyTagOpenContext.class,0);
5089                }
5090                public BodyTagCloseContext bodyTagClose() {
5091                        return getRuleContext(BodyTagCloseContext.class,0);
5092                }
5093                public List<HtmlTagContext> htmlTag() {
5094                        return getRuleContexts(HtmlTagContext.class);
5095                }
5096                public HtmlTagContext htmlTag(int i) {
5097                        return getRuleContext(HtmlTagContext.class,i);
5098                }
5099                public List<SingletonTagContext> singletonTag() {
5100                        return getRuleContexts(SingletonTagContext.class);
5101                }
5102                public SingletonTagContext singletonTag(int i) {
5103                        return getRuleContext(SingletonTagContext.class,i);
5104                }
5105                public List<ParagraphContext> paragraph() {
5106                        return getRuleContexts(ParagraphContext.class);
5107                }
5108                public ParagraphContext paragraph(int i) {
5109                        return getRuleContext(ParagraphContext.class,i);
5110                }
5111                public List<LiContext> li() {
5112                        return getRuleContexts(LiContext.class);
5113                }
5114                public LiContext li(int i) {
5115                        return getRuleContext(LiContext.class,i);
5116                }
5117                public List<TrContext> tr() {
5118                        return getRuleContexts(TrContext.class);
5119                }
5120                public TrContext tr(int i) {
5121                        return getRuleContext(TrContext.class,i);
5122                }
5123                public List<TdContext> td() {
5124                        return getRuleContexts(TdContext.class);
5125                }
5126                public TdContext td(int i) {
5127                        return getRuleContext(TdContext.class,i);
5128                }
5129                public List<ThContext> th() {
5130                        return getRuleContexts(ThContext.class);
5131                }
5132                public ThContext th(int i) {
5133                        return getRuleContext(ThContext.class,i);
5134                }
5135                public List<ColgroupContext> colgroup() {
5136                        return getRuleContexts(ColgroupContext.class);
5137                }
5138                public ColgroupContext colgroup(int i) {
5139                        return getRuleContext(ColgroupContext.class,i);
5140                }
5141                public List<DdContext> dd() {
5142                        return getRuleContexts(DdContext.class);
5143                }
5144                public DdContext dd(int i) {
5145                        return getRuleContext(DdContext.class,i);
5146                }
5147                public List<DtContext> dt() {
5148                        return getRuleContexts(DtContext.class);
5149                }
5150                public DtContext dt(int i) {
5151                        return getRuleContext(DtContext.class,i);
5152                }
5153                public List<HeadContext> head() {
5154                        return getRuleContexts(HeadContext.class);
5155                }
5156                public HeadContext head(int i) {
5157                        return getRuleContext(HeadContext.class,i);
5158                }
5159                public List<HtmlContext> html() {
5160                        return getRuleContexts(HtmlContext.class);
5161                }
5162                public HtmlContext html(int i) {
5163                        return getRuleContext(HtmlContext.class,i);
5164                }
5165                public List<OptionContext> option() {
5166                        return getRuleContexts(OptionContext.class);
5167                }
5168                public OptionContext option(int i) {
5169                        return getRuleContext(OptionContext.class,i);
5170                }
5171                public List<TbodyContext> tbody() {
5172                        return getRuleContexts(TbodyContext.class);
5173                }
5174                public TbodyContext tbody(int i) {
5175                        return getRuleContext(TbodyContext.class,i);
5176                }
5177                public List<TheadContext> thead() {
5178                        return getRuleContexts(TheadContext.class);
5179                }
5180                public TheadContext thead(int i) {
5181                        return getRuleContext(TheadContext.class,i);
5182                }
5183                public List<TfootContext> tfoot() {
5184                        return getRuleContexts(TfootContext.class);
5185                }
5186                public TfootContext tfoot(int i) {
5187                        return getRuleContext(TfootContext.class,i);
5188                }
5189                public List<PTagOpenContext> pTagOpen() {
5190                        return getRuleContexts(PTagOpenContext.class);
5191                }
5192                public PTagOpenContext pTagOpen(int i) {
5193                        return getRuleContext(PTagOpenContext.class,i);
5194                }
5195                public List<LiTagOpenContext> liTagOpen() {
5196                        return getRuleContexts(LiTagOpenContext.class);
5197                }
5198                public LiTagOpenContext liTagOpen(int i) {
5199                        return getRuleContext(LiTagOpenContext.class,i);
5200                }
5201                public List<TrTagOpenContext> trTagOpen() {
5202                        return getRuleContexts(TrTagOpenContext.class);
5203                }
5204                public TrTagOpenContext trTagOpen(int i) {
5205                        return getRuleContext(TrTagOpenContext.class,i);
5206                }
5207                public List<TdTagOpenContext> tdTagOpen() {
5208                        return getRuleContexts(TdTagOpenContext.class);
5209                }
5210                public TdTagOpenContext tdTagOpen(int i) {
5211                        return getRuleContext(TdTagOpenContext.class,i);
5212                }
5213                public List<ThTagOpenContext> thTagOpen() {
5214                        return getRuleContexts(ThTagOpenContext.class);
5215                }
5216                public ThTagOpenContext thTagOpen(int i) {
5217                        return getRuleContext(ThTagOpenContext.class,i);
5218                }
5219                public List<ColgroupTagOpenContext> colgroupTagOpen() {
5220                        return getRuleContexts(ColgroupTagOpenContext.class);
5221                }
5222                public ColgroupTagOpenContext colgroupTagOpen(int i) {
5223                        return getRuleContext(ColgroupTagOpenContext.class,i);
5224                }
5225                public List<DdTagOpenContext> ddTagOpen() {
5226                        return getRuleContexts(DdTagOpenContext.class);
5227                }
5228                public DdTagOpenContext ddTagOpen(int i) {
5229                        return getRuleContext(DdTagOpenContext.class,i);
5230                }
5231                public List<DtTagOpenContext> dtTagOpen() {
5232                        return getRuleContexts(DtTagOpenContext.class);
5233                }
5234                public DtTagOpenContext dtTagOpen(int i) {
5235                        return getRuleContext(DtTagOpenContext.class,i);
5236                }
5237                public List<HeadTagOpenContext> headTagOpen() {
5238                        return getRuleContexts(HeadTagOpenContext.class);
5239                }
5240                public HeadTagOpenContext headTagOpen(int i) {
5241                        return getRuleContext(HeadTagOpenContext.class,i);
5242                }
5243                public List<HtmlTagOpenContext> htmlTagOpen() {
5244                        return getRuleContexts(HtmlTagOpenContext.class);
5245                }
5246                public HtmlTagOpenContext htmlTagOpen(int i) {
5247                        return getRuleContext(HtmlTagOpenContext.class,i);
5248                }
5249                public List<OptionTagOpenContext> optionTagOpen() {
5250                        return getRuleContexts(OptionTagOpenContext.class);
5251                }
5252                public OptionTagOpenContext optionTagOpen(int i) {
5253                        return getRuleContext(OptionTagOpenContext.class,i);
5254                }
5255                public List<TbodyTagOpenContext> tbodyTagOpen() {
5256                        return getRuleContexts(TbodyTagOpenContext.class);
5257                }
5258                public TbodyTagOpenContext tbodyTagOpen(int i) {
5259                        return getRuleContext(TbodyTagOpenContext.class,i);
5260                }
5261                public List<TheadTagOpenContext> theadTagOpen() {
5262                        return getRuleContexts(TheadTagOpenContext.class);
5263                }
5264                public TheadTagOpenContext theadTagOpen(int i) {
5265                        return getRuleContext(TheadTagOpenContext.class,i);
5266                }
5267                public List<TfootTagOpenContext> tfootTagOpen() {
5268                        return getRuleContexts(TfootTagOpenContext.class);
5269                }
5270                public TfootTagOpenContext tfootTagOpen(int i) {
5271                        return getRuleContext(TfootTagOpenContext.class,i);
5272                }
5273                public List<HtmlCommentContext> htmlComment() {
5274                        return getRuleContexts(HtmlCommentContext.class);
5275                }
5276                public HtmlCommentContext htmlComment(int i) {
5277                        return getRuleContext(HtmlCommentContext.class,i);
5278                }
5279                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5280                public TerminalNode CDATA(int i) {
5281                        return getToken(JavadocParser.CDATA, i);
5282                }
5283                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5284                public TerminalNode NEWLINE(int i) {
5285                        return getToken(JavadocParser.NEWLINE, i);
5286                }
5287                public List<TextContext> text() {
5288                        return getRuleContexts(TextContext.class);
5289                }
5290                public TextContext text(int i) {
5291                        return getRuleContext(TextContext.class,i);
5292                }
5293                public List<JavadocInlineTagContext> javadocInlineTag() {
5294                        return getRuleContexts(JavadocInlineTagContext.class);
5295                }
5296                public JavadocInlineTagContext javadocInlineTag(int i) {
5297                        return getRuleContext(JavadocInlineTagContext.class,i);
5298                }
5299                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5300                public TerminalNode LEADING_ASTERISK(int i) {
5301                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5302                }
5303                public BodyContext(ParserRuleContext parent, int invokingState) {
5304                        super(parent, invokingState);
5305                }
5306                @Override public int getRuleIndex() { return RULE_body; }
5307                @Override
5308                public void enterRule(ParseTreeListener listener) {
5309                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this);
5310                }
5311                @Override
5312                public void exitRule(ParseTreeListener listener) {
5313                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this);
5314                }
5315                @Override
5316                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5317                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this);
5318                        else return visitor.visitChildren(this);
5319                }
5320        }
5321
5322        public final BodyContext body() throws RecognitionException {
5323                BodyContext _localctx = new BodyContext(_ctx, getState());
5324                enterRule(_localctx, 46, RULE_body);
5325                try {
5326                        int _alt;
5327                        enterOuterAlt(_localctx, 1);
5328                        {
5329                        setState(675);
5330                        bodyTagOpen();
5331                        setState(715);
5332                        _errHandler.sync(this);
5333                        _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5334                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5335                                if ( _alt==1 ) {
5336                                        {
5337                                        setState(713);
5338                                        _errHandler.sync(this);
5339                                        switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
5340                                        case 1:
5341                                                {
5342                                                setState(676);
5343                                                htmlTag();
5344                                                }
5345                                                break;
5346                                        case 2:
5347                                                {
5348                                                setState(677);
5349                                                singletonTag();
5350                                                }
5351                                                break;
5352                                        case 3:
5353                                                {
5354                                                setState(678);
5355                                                paragraph();
5356                                                }
5357                                                break;
5358                                        case 4:
5359                                                {
5360                                                setState(679);
5361                                                li();
5362                                                }
5363                                                break;
5364                                        case 5:
5365                                                {
5366                                                setState(680);
5367                                                tr();
5368                                                }
5369                                                break;
5370                                        case 6:
5371                                                {
5372                                                setState(681);
5373                                                td();
5374                                                }
5375                                                break;
5376                                        case 7:
5377                                                {
5378                                                setState(682);
5379                                                th();
5380                                                }
5381                                                break;
5382                                        case 8:
5383                                                {
5384                                                setState(683);
5385                                                colgroup();
5386                                                }
5387                                                break;
5388                                        case 9:
5389                                                {
5390                                                setState(684);
5391                                                dd();
5392                                                }
5393                                                break;
5394                                        case 10:
5395                                                {
5396                                                setState(685);
5397                                                dt();
5398                                                }
5399                                                break;
5400                                        case 11:
5401                                                {
5402                                                setState(686);
5403                                                head();
5404                                                }
5405                                                break;
5406                                        case 12:
5407                                                {
5408                                                setState(687);
5409                                                html();
5410                                                }
5411                                                break;
5412                                        case 13:
5413                                                {
5414                                                setState(688);
5415                                                option();
5416                                                }
5417                                                break;
5418                                        case 14:
5419                                                {
5420                                                setState(689);
5421                                                tbody();
5422                                                }
5423                                                break;
5424                                        case 15:
5425                                                {
5426                                                setState(690);
5427                                                thead();
5428                                                }
5429                                                break;
5430                                        case 16:
5431                                                {
5432                                                setState(691);
5433                                                tfoot();
5434                                                }
5435                                                break;
5436                                        case 17:
5437                                                {
5438                                                setState(692);
5439                                                pTagOpen();
5440                                                }
5441                                                break;
5442                                        case 18:
5443                                                {
5444                                                setState(693);
5445                                                liTagOpen();
5446                                                }
5447                                                break;
5448                                        case 19:
5449                                                {
5450                                                setState(694);
5451                                                trTagOpen();
5452                                                }
5453                                                break;
5454                                        case 20:
5455                                                {
5456                                                setState(695);
5457                                                tdTagOpen();
5458                                                }
5459                                                break;
5460                                        case 21:
5461                                                {
5462                                                setState(696);
5463                                                thTagOpen();
5464                                                }
5465                                                break;
5466                                        case 22:
5467                                                {
5468                                                setState(697);
5469                                                colgroupTagOpen();
5470                                                }
5471                                                break;
5472                                        case 23:
5473                                                {
5474                                                setState(698);
5475                                                ddTagOpen();
5476                                                }
5477                                                break;
5478                                        case 24:
5479                                                {
5480                                                setState(699);
5481                                                dtTagOpen();
5482                                                }
5483                                                break;
5484                                        case 25:
5485                                                {
5486                                                setState(700);
5487                                                headTagOpen();
5488                                                }
5489                                                break;
5490                                        case 26:
5491                                                {
5492                                                setState(701);
5493                                                htmlTagOpen();
5494                                                }
5495                                                break;
5496                                        case 27:
5497                                                {
5498                                                setState(702);
5499                                                optionTagOpen();
5500                                                }
5501                                                break;
5502                                        case 28:
5503                                                {
5504                                                setState(703);
5505                                                tbodyTagOpen();
5506                                                }
5507                                                break;
5508                                        case 29:
5509                                                {
5510                                                setState(704);
5511                                                theadTagOpen();
5512                                                }
5513                                                break;
5514                                        case 30:
5515                                                {
5516                                                setState(705);
5517                                                tfootTagOpen();
5518                                                }
5519                                                break;
5520                                        case 31:
5521                                                {
5522                                                {
5523                                                setState(706);
5524                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5525                                                setState(707);
5526                                                match(LEADING_ASTERISK);
5527                                                }
5528                                                }
5529                                                break;
5530                                        case 32:
5531                                                {
5532                                                setState(708);
5533                                                htmlComment();
5534                                                }
5535                                                break;
5536                                        case 33:
5537                                                {
5538                                                setState(709);
5539                                                match(CDATA);
5540                                                }
5541                                                break;
5542                                        case 34:
5543                                                {
5544                                                setState(710);
5545                                                match(NEWLINE);
5546                                                }
5547                                                break;
5548                                        case 35:
5549                                                {
5550                                                setState(711);
5551                                                text();
5552                                                }
5553                                                break;
5554                                        case 36:
5555                                                {
5556                                                setState(712);
5557                                                javadocInlineTag();
5558                                                }
5559                                                break;
5560                                        }
5561                                        } 
5562                                }
5563                                setState(717);
5564                                _errHandler.sync(this);
5565                                _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5566                        }
5567                        setState(718);
5568                        bodyTagClose();
5569                        }
5570                }
5571                catch (RecognitionException re) {
5572                        _localctx.exception = re;
5573                        _errHandler.reportError(this, re);
5574                        _errHandler.recover(this, re);
5575                }
5576                finally {
5577                        exitRule();
5578                }
5579                return _localctx;
5580        }
5581
5582        public static class ColgroupTagOpenContext extends ParserRuleContext {
5583                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5584                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5585                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5586                public List<AttributeContext> attribute() {
5587                        return getRuleContexts(AttributeContext.class);
5588                }
5589                public AttributeContext attribute(int i) {
5590                        return getRuleContext(AttributeContext.class,i);
5591                }
5592                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5593                public TerminalNode NEWLINE(int i) {
5594                        return getToken(JavadocParser.NEWLINE, i);
5595                }
5596                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5597                public TerminalNode LEADING_ASTERISK(int i) {
5598                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5599                }
5600                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5601                public TerminalNode WS(int i) {
5602                        return getToken(JavadocParser.WS, i);
5603                }
5604                public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) {
5605                        super(parent, invokingState);
5606                }
5607                @Override public int getRuleIndex() { return RULE_colgroupTagOpen; }
5608                @Override
5609                public void enterRule(ParseTreeListener listener) {
5610                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this);
5611                }
5612                @Override
5613                public void exitRule(ParseTreeListener listener) {
5614                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this);
5615                }
5616                @Override
5617                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5618                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this);
5619                        else return visitor.visitChildren(this);
5620                }
5621        }
5622
5623        public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException {
5624                ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState());
5625                enterRule(_localctx, 48, RULE_colgroupTagOpen);
5626                int _la;
5627                try {
5628                        enterOuterAlt(_localctx, 1);
5629                        {
5630                        setState(720);
5631                        match(OPEN);
5632                        setState(721);
5633                        match(COLGROUP_HTML_TAG_NAME);
5634                        setState(728);
5635                        _errHandler.sync(this);
5636                        _la = _input.LA(1);
5637                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5638                                {
5639                                setState(726);
5640                                _errHandler.sync(this);
5641                                switch (_input.LA(1)) {
5642                                case HTML_TAG_NAME:
5643                                        {
5644                                        setState(722);
5645                                        attribute();
5646                                        }
5647                                        break;
5648                                case NEWLINE:
5649                                        {
5650                                        setState(723);
5651                                        match(NEWLINE);
5652                                        }
5653                                        break;
5654                                case LEADING_ASTERISK:
5655                                        {
5656                                        setState(724);
5657                                        match(LEADING_ASTERISK);
5658                                        }
5659                                        break;
5660                                case WS:
5661                                        {
5662                                        setState(725);
5663                                        match(WS);
5664                                        }
5665                                        break;
5666                                default:
5667                                        throw new NoViableAltException(this);
5668                                }
5669                                }
5670                                setState(730);
5671                                _errHandler.sync(this);
5672                                _la = _input.LA(1);
5673                        }
5674                        setState(731);
5675                        match(CLOSE);
5676                        }
5677                }
5678                catch (RecognitionException re) {
5679                        _localctx.exception = re;
5680                        _errHandler.reportError(this, re);
5681                        _errHandler.recover(this, re);
5682                }
5683                finally {
5684                        exitRule();
5685                }
5686                return _localctx;
5687        }
5688
5689        public static class ColgroupTagCloseContext extends ParserRuleContext {
5690                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5691                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5692                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5693                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5694                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5695                public TerminalNode NEWLINE(int i) {
5696                        return getToken(JavadocParser.NEWLINE, i);
5697                }
5698                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5699                public TerminalNode LEADING_ASTERISK(int i) {
5700                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5701                }
5702                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5703                public TerminalNode WS(int i) {
5704                        return getToken(JavadocParser.WS, i);
5705                }
5706                public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) {
5707                        super(parent, invokingState);
5708                }
5709                @Override public int getRuleIndex() { return RULE_colgroupTagClose; }
5710                @Override
5711                public void enterRule(ParseTreeListener listener) {
5712                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this);
5713                }
5714                @Override
5715                public void exitRule(ParseTreeListener listener) {
5716                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this);
5717                }
5718                @Override
5719                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5720                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this);
5721                        else return visitor.visitChildren(this);
5722                }
5723        }
5724
5725        public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException {
5726                ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState());
5727                enterRule(_localctx, 50, RULE_colgroupTagClose);
5728                int _la;
5729                try {
5730                        enterOuterAlt(_localctx, 1);
5731                        {
5732                        setState(733);
5733                        match(OPEN);
5734                        setState(734);
5735                        match(SLASH);
5736                        setState(735);
5737                        match(COLGROUP_HTML_TAG_NAME);
5738                        setState(739);
5739                        _errHandler.sync(this);
5740                        _la = _input.LA(1);
5741                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5742                                {
5743                                {
5744                                setState(736);
5745                                _la = _input.LA(1);
5746                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5747                                _errHandler.recoverInline(this);
5748                                }
5749                                else {
5750                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
5751                                        _errHandler.reportMatch(this);
5752                                        consume();
5753                                }
5754                                }
5755                                }
5756                                setState(741);
5757                                _errHandler.sync(this);
5758                                _la = _input.LA(1);
5759                        }
5760                        setState(742);
5761                        match(CLOSE);
5762                        }
5763                }
5764                catch (RecognitionException re) {
5765                        _localctx.exception = re;
5766                        _errHandler.reportError(this, re);
5767                        _errHandler.recover(this, re);
5768                }
5769                finally {
5770                        exitRule();
5771                }
5772                return _localctx;
5773        }
5774
5775        public static class ColgroupContext extends ParserRuleContext {
5776                public ColgroupTagOpenContext colgroupTagOpen() {
5777                        return getRuleContext(ColgroupTagOpenContext.class,0);
5778                }
5779                public ColgroupTagCloseContext colgroupTagClose() {
5780                        return getRuleContext(ColgroupTagCloseContext.class,0);
5781                }
5782                public List<HtmlTagContext> htmlTag() {
5783                        return getRuleContexts(HtmlTagContext.class);
5784                }
5785                public HtmlTagContext htmlTag(int i) {
5786                        return getRuleContext(HtmlTagContext.class,i);
5787                }
5788                public List<SingletonTagContext> singletonTag() {
5789                        return getRuleContexts(SingletonTagContext.class);
5790                }
5791                public SingletonTagContext singletonTag(int i) {
5792                        return getRuleContext(SingletonTagContext.class,i);
5793                }
5794                public List<ParagraphContext> paragraph() {
5795                        return getRuleContexts(ParagraphContext.class);
5796                }
5797                public ParagraphContext paragraph(int i) {
5798                        return getRuleContext(ParagraphContext.class,i);
5799                }
5800                public List<LiContext> li() {
5801                        return getRuleContexts(LiContext.class);
5802                }
5803                public LiContext li(int i) {
5804                        return getRuleContext(LiContext.class,i);
5805                }
5806                public List<TrContext> tr() {
5807                        return getRuleContexts(TrContext.class);
5808                }
5809                public TrContext tr(int i) {
5810                        return getRuleContext(TrContext.class,i);
5811                }
5812                public List<TdContext> td() {
5813                        return getRuleContexts(TdContext.class);
5814                }
5815                public TdContext td(int i) {
5816                        return getRuleContext(TdContext.class,i);
5817                }
5818                public List<ThContext> th() {
5819                        return getRuleContexts(ThContext.class);
5820                }
5821                public ThContext th(int i) {
5822                        return getRuleContext(ThContext.class,i);
5823                }
5824                public List<BodyContext> body() {
5825                        return getRuleContexts(BodyContext.class);
5826                }
5827                public BodyContext body(int i) {
5828                        return getRuleContext(BodyContext.class,i);
5829                }
5830                public List<DdContext> dd() {
5831                        return getRuleContexts(DdContext.class);
5832                }
5833                public DdContext dd(int i) {
5834                        return getRuleContext(DdContext.class,i);
5835                }
5836                public List<DtContext> dt() {
5837                        return getRuleContexts(DtContext.class);
5838                }
5839                public DtContext dt(int i) {
5840                        return getRuleContext(DtContext.class,i);
5841                }
5842                public List<HeadContext> head() {
5843                        return getRuleContexts(HeadContext.class);
5844                }
5845                public HeadContext head(int i) {
5846                        return getRuleContext(HeadContext.class,i);
5847                }
5848                public List<HtmlContext> html() {
5849                        return getRuleContexts(HtmlContext.class);
5850                }
5851                public HtmlContext html(int i) {
5852                        return getRuleContext(HtmlContext.class,i);
5853                }
5854                public List<OptionContext> option() {
5855                        return getRuleContexts(OptionContext.class);
5856                }
5857                public OptionContext option(int i) {
5858                        return getRuleContext(OptionContext.class,i);
5859                }
5860                public List<TbodyContext> tbody() {
5861                        return getRuleContexts(TbodyContext.class);
5862                }
5863                public TbodyContext tbody(int i) {
5864                        return getRuleContext(TbodyContext.class,i);
5865                }
5866                public List<TheadContext> thead() {
5867                        return getRuleContexts(TheadContext.class);
5868                }
5869                public TheadContext thead(int i) {
5870                        return getRuleContext(TheadContext.class,i);
5871                }
5872                public List<TfootContext> tfoot() {
5873                        return getRuleContexts(TfootContext.class);
5874                }
5875                public TfootContext tfoot(int i) {
5876                        return getRuleContext(TfootContext.class,i);
5877                }
5878                public List<PTagOpenContext> pTagOpen() {
5879                        return getRuleContexts(PTagOpenContext.class);
5880                }
5881                public PTagOpenContext pTagOpen(int i) {
5882                        return getRuleContext(PTagOpenContext.class,i);
5883                }
5884                public List<LiTagOpenContext> liTagOpen() {
5885                        return getRuleContexts(LiTagOpenContext.class);
5886                }
5887                public LiTagOpenContext liTagOpen(int i) {
5888                        return getRuleContext(LiTagOpenContext.class,i);
5889                }
5890                public List<TrTagOpenContext> trTagOpen() {
5891                        return getRuleContexts(TrTagOpenContext.class);
5892                }
5893                public TrTagOpenContext trTagOpen(int i) {
5894                        return getRuleContext(TrTagOpenContext.class,i);
5895                }
5896                public List<TdTagOpenContext> tdTagOpen() {
5897                        return getRuleContexts(TdTagOpenContext.class);
5898                }
5899                public TdTagOpenContext tdTagOpen(int i) {
5900                        return getRuleContext(TdTagOpenContext.class,i);
5901                }
5902                public List<ThTagOpenContext> thTagOpen() {
5903                        return getRuleContexts(ThTagOpenContext.class);
5904                }
5905                public ThTagOpenContext thTagOpen(int i) {
5906                        return getRuleContext(ThTagOpenContext.class,i);
5907                }
5908                public List<BodyTagOpenContext> bodyTagOpen() {
5909                        return getRuleContexts(BodyTagOpenContext.class);
5910                }
5911                public BodyTagOpenContext bodyTagOpen(int i) {
5912                        return getRuleContext(BodyTagOpenContext.class,i);
5913                }
5914                public List<DdTagOpenContext> ddTagOpen() {
5915                        return getRuleContexts(DdTagOpenContext.class);
5916                }
5917                public DdTagOpenContext ddTagOpen(int i) {
5918                        return getRuleContext(DdTagOpenContext.class,i);
5919                }
5920                public List<DtTagOpenContext> dtTagOpen() {
5921                        return getRuleContexts(DtTagOpenContext.class);
5922                }
5923                public DtTagOpenContext dtTagOpen(int i) {
5924                        return getRuleContext(DtTagOpenContext.class,i);
5925                }
5926                public List<HeadTagOpenContext> headTagOpen() {
5927                        return getRuleContexts(HeadTagOpenContext.class);
5928                }
5929                public HeadTagOpenContext headTagOpen(int i) {
5930                        return getRuleContext(HeadTagOpenContext.class,i);
5931                }
5932                public List<HtmlTagOpenContext> htmlTagOpen() {
5933                        return getRuleContexts(HtmlTagOpenContext.class);
5934                }
5935                public HtmlTagOpenContext htmlTagOpen(int i) {
5936                        return getRuleContext(HtmlTagOpenContext.class,i);
5937                }
5938                public List<OptionTagOpenContext> optionTagOpen() {
5939                        return getRuleContexts(OptionTagOpenContext.class);
5940                }
5941                public OptionTagOpenContext optionTagOpen(int i) {
5942                        return getRuleContext(OptionTagOpenContext.class,i);
5943                }
5944                public List<TbodyTagOpenContext> tbodyTagOpen() {
5945                        return getRuleContexts(TbodyTagOpenContext.class);
5946                }
5947                public TbodyTagOpenContext tbodyTagOpen(int i) {
5948                        return getRuleContext(TbodyTagOpenContext.class,i);
5949                }
5950                public List<TheadTagOpenContext> theadTagOpen() {
5951                        return getRuleContexts(TheadTagOpenContext.class);
5952                }
5953                public TheadTagOpenContext theadTagOpen(int i) {
5954                        return getRuleContext(TheadTagOpenContext.class,i);
5955                }
5956                public List<TfootTagOpenContext> tfootTagOpen() {
5957                        return getRuleContexts(TfootTagOpenContext.class);
5958                }
5959                public TfootTagOpenContext tfootTagOpen(int i) {
5960                        return getRuleContext(TfootTagOpenContext.class,i);
5961                }
5962                public List<HtmlCommentContext> htmlComment() {
5963                        return getRuleContexts(HtmlCommentContext.class);
5964                }
5965                public HtmlCommentContext htmlComment(int i) {
5966                        return getRuleContext(HtmlCommentContext.class,i);
5967                }
5968                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5969                public TerminalNode CDATA(int i) {
5970                        return getToken(JavadocParser.CDATA, i);
5971                }
5972                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5973                public TerminalNode NEWLINE(int i) {
5974                        return getToken(JavadocParser.NEWLINE, i);
5975                }
5976                public List<TextContext> text() {
5977                        return getRuleContexts(TextContext.class);
5978                }
5979                public TextContext text(int i) {
5980                        return getRuleContext(TextContext.class,i);
5981                }
5982                public List<JavadocInlineTagContext> javadocInlineTag() {
5983                        return getRuleContexts(JavadocInlineTagContext.class);
5984                }
5985                public JavadocInlineTagContext javadocInlineTag(int i) {
5986                        return getRuleContext(JavadocInlineTagContext.class,i);
5987                }
5988                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5989                public TerminalNode LEADING_ASTERISK(int i) {
5990                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5991                }
5992                public ColgroupContext(ParserRuleContext parent, int invokingState) {
5993                        super(parent, invokingState);
5994                }
5995                @Override public int getRuleIndex() { return RULE_colgroup; }
5996                @Override
5997                public void enterRule(ParseTreeListener listener) {
5998                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this);
5999                }
6000                @Override
6001                public void exitRule(ParseTreeListener listener) {
6002                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this);
6003                }
6004                @Override
6005                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6006                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this);
6007                        else return visitor.visitChildren(this);
6008                }
6009        }
6010
6011        public final ColgroupContext colgroup() throws RecognitionException {
6012                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
6013                enterRule(_localctx, 52, RULE_colgroup);
6014                try {
6015                        int _alt;
6016                        enterOuterAlt(_localctx, 1);
6017                        {
6018                        setState(744);
6019                        colgroupTagOpen();
6020                        setState(784);
6021                        _errHandler.sync(this);
6022                        _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6023                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6024                                if ( _alt==1 ) {
6025                                        {
6026                                        setState(782);
6027                                        _errHandler.sync(this);
6028                                        switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
6029                                        case 1:
6030                                                {
6031                                                setState(745);
6032                                                htmlTag();
6033                                                }
6034                                                break;
6035                                        case 2:
6036                                                {
6037                                                setState(746);
6038                                                singletonTag();
6039                                                }
6040                                                break;
6041                                        case 3:
6042                                                {
6043                                                setState(747);
6044                                                paragraph();
6045                                                }
6046                                                break;
6047                                        case 4:
6048                                                {
6049                                                setState(748);
6050                                                li();
6051                                                }
6052                                                break;
6053                                        case 5:
6054                                                {
6055                                                setState(749);
6056                                                tr();
6057                                                }
6058                                                break;
6059                                        case 6:
6060                                                {
6061                                                setState(750);
6062                                                td();
6063                                                }
6064                                                break;
6065                                        case 7:
6066                                                {
6067                                                setState(751);
6068                                                th();
6069                                                }
6070                                                break;
6071                                        case 8:
6072                                                {
6073                                                setState(752);
6074                                                body();
6075                                                }
6076                                                break;
6077                                        case 9:
6078                                                {
6079                                                setState(753);
6080                                                dd();
6081                                                }
6082                                                break;
6083                                        case 10:
6084                                                {
6085                                                setState(754);
6086                                                dt();
6087                                                }
6088                                                break;
6089                                        case 11:
6090                                                {
6091                                                setState(755);
6092                                                head();
6093                                                }
6094                                                break;
6095                                        case 12:
6096                                                {
6097                                                setState(756);
6098                                                html();
6099                                                }
6100                                                break;
6101                                        case 13:
6102                                                {
6103                                                setState(757);
6104                                                option();
6105                                                }
6106                                                break;
6107                                        case 14:
6108                                                {
6109                                                setState(758);
6110                                                tbody();
6111                                                }
6112                                                break;
6113                                        case 15:
6114                                                {
6115                                                setState(759);
6116                                                thead();
6117                                                }
6118                                                break;
6119                                        case 16:
6120                                                {
6121                                                setState(760);
6122                                                tfoot();
6123                                                }
6124                                                break;
6125                                        case 17:
6126                                                {
6127                                                setState(761);
6128                                                pTagOpen();
6129                                                }
6130                                                break;
6131                                        case 18:
6132                                                {
6133                                                setState(762);
6134                                                liTagOpen();
6135                                                }
6136                                                break;
6137                                        case 19:
6138                                                {
6139                                                setState(763);
6140                                                trTagOpen();
6141                                                }
6142                                                break;
6143                                        case 20:
6144                                                {
6145                                                setState(764);
6146                                                tdTagOpen();
6147                                                }
6148                                                break;
6149                                        case 21:
6150                                                {
6151                                                setState(765);
6152                                                thTagOpen();
6153                                                }
6154                                                break;
6155                                        case 22:
6156                                                {
6157                                                setState(766);
6158                                                bodyTagOpen();
6159                                                }
6160                                                break;
6161                                        case 23:
6162                                                {
6163                                                setState(767);
6164                                                ddTagOpen();
6165                                                }
6166                                                break;
6167                                        case 24:
6168                                                {
6169                                                setState(768);
6170                                                dtTagOpen();
6171                                                }
6172                                                break;
6173                                        case 25:
6174                                                {
6175                                                setState(769);
6176                                                headTagOpen();
6177                                                }
6178                                                break;
6179                                        case 26:
6180                                                {
6181                                                setState(770);
6182                                                htmlTagOpen();
6183                                                }
6184                                                break;
6185                                        case 27:
6186                                                {
6187                                                setState(771);
6188                                                optionTagOpen();
6189                                                }
6190                                                break;
6191                                        case 28:
6192                                                {
6193                                                setState(772);
6194                                                tbodyTagOpen();
6195                                                }
6196                                                break;
6197                                        case 29:
6198                                                {
6199                                                setState(773);
6200                                                theadTagOpen();
6201                                                }
6202                                                break;
6203                                        case 30:
6204                                                {
6205                                                setState(774);
6206                                                tfootTagOpen();
6207                                                }
6208                                                break;
6209                                        case 31:
6210                                                {
6211                                                {
6212                                                setState(775);
6213                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6214                                                setState(776);
6215                                                match(LEADING_ASTERISK);
6216                                                }
6217                                                }
6218                                                break;
6219                                        case 32:
6220                                                {
6221                                                setState(777);
6222                                                htmlComment();
6223                                                }
6224                                                break;
6225                                        case 33:
6226                                                {
6227                                                setState(778);
6228                                                match(CDATA);
6229                                                }
6230                                                break;
6231                                        case 34:
6232                                                {
6233                                                setState(779);
6234                                                match(NEWLINE);
6235                                                }
6236                                                break;
6237                                        case 35:
6238                                                {
6239                                                setState(780);
6240                                                text();
6241                                                }
6242                                                break;
6243                                        case 36:
6244                                                {
6245                                                setState(781);
6246                                                javadocInlineTag();
6247                                                }
6248                                                break;
6249                                        }
6250                                        } 
6251                                }
6252                                setState(786);
6253                                _errHandler.sync(this);
6254                                _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6255                        }
6256                        setState(787);
6257                        colgroupTagClose();
6258                        }
6259                }
6260                catch (RecognitionException re) {
6261                        _localctx.exception = re;
6262                        _errHandler.reportError(this, re);
6263                        _errHandler.recover(this, re);
6264                }
6265                finally {
6266                        exitRule();
6267                }
6268                return _localctx;
6269        }
6270
6271        public static class DdTagOpenContext extends ParserRuleContext {
6272                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6273                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6274                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6275                public List<AttributeContext> attribute() {
6276                        return getRuleContexts(AttributeContext.class);
6277                }
6278                public AttributeContext attribute(int i) {
6279                        return getRuleContext(AttributeContext.class,i);
6280                }
6281                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6282                public TerminalNode NEWLINE(int i) {
6283                        return getToken(JavadocParser.NEWLINE, i);
6284                }
6285                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6286                public TerminalNode LEADING_ASTERISK(int i) {
6287                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6288                }
6289                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6290                public TerminalNode WS(int i) {
6291                        return getToken(JavadocParser.WS, i);
6292                }
6293                public DdTagOpenContext(ParserRuleContext parent, int invokingState) {
6294                        super(parent, invokingState);
6295                }
6296                @Override public int getRuleIndex() { return RULE_ddTagOpen; }
6297                @Override
6298                public void enterRule(ParseTreeListener listener) {
6299                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this);
6300                }
6301                @Override
6302                public void exitRule(ParseTreeListener listener) {
6303                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this);
6304                }
6305                @Override
6306                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6307                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this);
6308                        else return visitor.visitChildren(this);
6309                }
6310        }
6311
6312        public final DdTagOpenContext ddTagOpen() throws RecognitionException {
6313                DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState());
6314                enterRule(_localctx, 54, RULE_ddTagOpen);
6315                int _la;
6316                try {
6317                        enterOuterAlt(_localctx, 1);
6318                        {
6319                        setState(789);
6320                        match(OPEN);
6321                        setState(790);
6322                        match(DD_HTML_TAG_NAME);
6323                        setState(797);
6324                        _errHandler.sync(this);
6325                        _la = _input.LA(1);
6326                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6327                                {
6328                                setState(795);
6329                                _errHandler.sync(this);
6330                                switch (_input.LA(1)) {
6331                                case HTML_TAG_NAME:
6332                                        {
6333                                        setState(791);
6334                                        attribute();
6335                                        }
6336                                        break;
6337                                case NEWLINE:
6338                                        {
6339                                        setState(792);
6340                                        match(NEWLINE);
6341                                        }
6342                                        break;
6343                                case LEADING_ASTERISK:
6344                                        {
6345                                        setState(793);
6346                                        match(LEADING_ASTERISK);
6347                                        }
6348                                        break;
6349                                case WS:
6350                                        {
6351                                        setState(794);
6352                                        match(WS);
6353                                        }
6354                                        break;
6355                                default:
6356                                        throw new NoViableAltException(this);
6357                                }
6358                                }
6359                                setState(799);
6360                                _errHandler.sync(this);
6361                                _la = _input.LA(1);
6362                        }
6363                        setState(800);
6364                        match(CLOSE);
6365                        }
6366                }
6367                catch (RecognitionException re) {
6368                        _localctx.exception = re;
6369                        _errHandler.reportError(this, re);
6370                        _errHandler.recover(this, re);
6371                }
6372                finally {
6373                        exitRule();
6374                }
6375                return _localctx;
6376        }
6377
6378        public static class DdTagCloseContext extends ParserRuleContext {
6379                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6380                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6381                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6382                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6383                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6384                public TerminalNode NEWLINE(int i) {
6385                        return getToken(JavadocParser.NEWLINE, i);
6386                }
6387                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6388                public TerminalNode LEADING_ASTERISK(int i) {
6389                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6390                }
6391                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6392                public TerminalNode WS(int i) {
6393                        return getToken(JavadocParser.WS, i);
6394                }
6395                public DdTagCloseContext(ParserRuleContext parent, int invokingState) {
6396                        super(parent, invokingState);
6397                }
6398                @Override public int getRuleIndex() { return RULE_ddTagClose; }
6399                @Override
6400                public void enterRule(ParseTreeListener listener) {
6401                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this);
6402                }
6403                @Override
6404                public void exitRule(ParseTreeListener listener) {
6405                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this);
6406                }
6407                @Override
6408                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6409                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this);
6410                        else return visitor.visitChildren(this);
6411                }
6412        }
6413
6414        public final DdTagCloseContext ddTagClose() throws RecognitionException {
6415                DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState());
6416                enterRule(_localctx, 56, RULE_ddTagClose);
6417                int _la;
6418                try {
6419                        enterOuterAlt(_localctx, 1);
6420                        {
6421                        setState(802);
6422                        match(OPEN);
6423                        setState(803);
6424                        match(SLASH);
6425                        setState(804);
6426                        match(DD_HTML_TAG_NAME);
6427                        setState(808);
6428                        _errHandler.sync(this);
6429                        _la = _input.LA(1);
6430                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6431                                {
6432                                {
6433                                setState(805);
6434                                _la = _input.LA(1);
6435                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6436                                _errHandler.recoverInline(this);
6437                                }
6438                                else {
6439                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
6440                                        _errHandler.reportMatch(this);
6441                                        consume();
6442                                }
6443                                }
6444                                }
6445                                setState(810);
6446                                _errHandler.sync(this);
6447                                _la = _input.LA(1);
6448                        }
6449                        setState(811);
6450                        match(CLOSE);
6451                        }
6452                }
6453                catch (RecognitionException re) {
6454                        _localctx.exception = re;
6455                        _errHandler.reportError(this, re);
6456                        _errHandler.recover(this, re);
6457                }
6458                finally {
6459                        exitRule();
6460                }
6461                return _localctx;
6462        }
6463
6464        public static class DdContext extends ParserRuleContext {
6465                public DdTagOpenContext ddTagOpen() {
6466                        return getRuleContext(DdTagOpenContext.class,0);
6467                }
6468                public DdTagCloseContext ddTagClose() {
6469                        return getRuleContext(DdTagCloseContext.class,0);
6470                }
6471                public List<HtmlTagContext> htmlTag() {
6472                        return getRuleContexts(HtmlTagContext.class);
6473                }
6474                public HtmlTagContext htmlTag(int i) {
6475                        return getRuleContext(HtmlTagContext.class,i);
6476                }
6477                public List<SingletonTagContext> singletonTag() {
6478                        return getRuleContexts(SingletonTagContext.class);
6479                }
6480                public SingletonTagContext singletonTag(int i) {
6481                        return getRuleContext(SingletonTagContext.class,i);
6482                }
6483                public List<ParagraphContext> paragraph() {
6484                        return getRuleContexts(ParagraphContext.class);
6485                }
6486                public ParagraphContext paragraph(int i) {
6487                        return getRuleContext(ParagraphContext.class,i);
6488                }
6489                public List<LiContext> li() {
6490                        return getRuleContexts(LiContext.class);
6491                }
6492                public LiContext li(int i) {
6493                        return getRuleContext(LiContext.class,i);
6494                }
6495                public List<TrContext> tr() {
6496                        return getRuleContexts(TrContext.class);
6497                }
6498                public TrContext tr(int i) {
6499                        return getRuleContext(TrContext.class,i);
6500                }
6501                public List<TdContext> td() {
6502                        return getRuleContexts(TdContext.class);
6503                }
6504                public TdContext td(int i) {
6505                        return getRuleContext(TdContext.class,i);
6506                }
6507                public List<ThContext> th() {
6508                        return getRuleContexts(ThContext.class);
6509                }
6510                public ThContext th(int i) {
6511                        return getRuleContext(ThContext.class,i);
6512                }
6513                public List<BodyContext> body() {
6514                        return getRuleContexts(BodyContext.class);
6515                }
6516                public BodyContext body(int i) {
6517                        return getRuleContext(BodyContext.class,i);
6518                }
6519                public List<ColgroupContext> colgroup() {
6520                        return getRuleContexts(ColgroupContext.class);
6521                }
6522                public ColgroupContext colgroup(int i) {
6523                        return getRuleContext(ColgroupContext.class,i);
6524                }
6525                public List<DtContext> dt() {
6526                        return getRuleContexts(DtContext.class);
6527                }
6528                public DtContext dt(int i) {
6529                        return getRuleContext(DtContext.class,i);
6530                }
6531                public List<HeadContext> head() {
6532                        return getRuleContexts(HeadContext.class);
6533                }
6534                public HeadContext head(int i) {
6535                        return getRuleContext(HeadContext.class,i);
6536                }
6537                public List<HtmlContext> html() {
6538                        return getRuleContexts(HtmlContext.class);
6539                }
6540                public HtmlContext html(int i) {
6541                        return getRuleContext(HtmlContext.class,i);
6542                }
6543                public List<OptionContext> option() {
6544                        return getRuleContexts(OptionContext.class);
6545                }
6546                public OptionContext option(int i) {
6547                        return getRuleContext(OptionContext.class,i);
6548                }
6549                public List<TbodyContext> tbody() {
6550                        return getRuleContexts(TbodyContext.class);
6551                }
6552                public TbodyContext tbody(int i) {
6553                        return getRuleContext(TbodyContext.class,i);
6554                }
6555                public List<TheadContext> thead() {
6556                        return getRuleContexts(TheadContext.class);
6557                }
6558                public TheadContext thead(int i) {
6559                        return getRuleContext(TheadContext.class,i);
6560                }
6561                public List<TfootContext> tfoot() {
6562                        return getRuleContexts(TfootContext.class);
6563                }
6564                public TfootContext tfoot(int i) {
6565                        return getRuleContext(TfootContext.class,i);
6566                }
6567                public List<PTagOpenContext> pTagOpen() {
6568                        return getRuleContexts(PTagOpenContext.class);
6569                }
6570                public PTagOpenContext pTagOpen(int i) {
6571                        return getRuleContext(PTagOpenContext.class,i);
6572                }
6573                public List<LiTagOpenContext> liTagOpen() {
6574                        return getRuleContexts(LiTagOpenContext.class);
6575                }
6576                public LiTagOpenContext liTagOpen(int i) {
6577                        return getRuleContext(LiTagOpenContext.class,i);
6578                }
6579                public List<TrTagOpenContext> trTagOpen() {
6580                        return getRuleContexts(TrTagOpenContext.class);
6581                }
6582                public TrTagOpenContext trTagOpen(int i) {
6583                        return getRuleContext(TrTagOpenContext.class,i);
6584                }
6585                public List<TdTagOpenContext> tdTagOpen() {
6586                        return getRuleContexts(TdTagOpenContext.class);
6587                }
6588                public TdTagOpenContext tdTagOpen(int i) {
6589                        return getRuleContext(TdTagOpenContext.class,i);
6590                }
6591                public List<ThTagOpenContext> thTagOpen() {
6592                        return getRuleContexts(ThTagOpenContext.class);
6593                }
6594                public ThTagOpenContext thTagOpen(int i) {
6595                        return getRuleContext(ThTagOpenContext.class,i);
6596                }
6597                public List<BodyTagOpenContext> bodyTagOpen() {
6598                        return getRuleContexts(BodyTagOpenContext.class);
6599                }
6600                public BodyTagOpenContext bodyTagOpen(int i) {
6601                        return getRuleContext(BodyTagOpenContext.class,i);
6602                }
6603                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6604                        return getRuleContexts(ColgroupTagOpenContext.class);
6605                }
6606                public ColgroupTagOpenContext colgroupTagOpen(int i) {
6607                        return getRuleContext(ColgroupTagOpenContext.class,i);
6608                }
6609                public List<DtTagOpenContext> dtTagOpen() {
6610                        return getRuleContexts(DtTagOpenContext.class);
6611                }
6612                public DtTagOpenContext dtTagOpen(int i) {
6613                        return getRuleContext(DtTagOpenContext.class,i);
6614                }
6615                public List<HeadTagOpenContext> headTagOpen() {
6616                        return getRuleContexts(HeadTagOpenContext.class);
6617                }
6618                public HeadTagOpenContext headTagOpen(int i) {
6619                        return getRuleContext(HeadTagOpenContext.class,i);
6620                }
6621                public List<HtmlTagOpenContext> htmlTagOpen() {
6622                        return getRuleContexts(HtmlTagOpenContext.class);
6623                }
6624                public HtmlTagOpenContext htmlTagOpen(int i) {
6625                        return getRuleContext(HtmlTagOpenContext.class,i);
6626                }
6627                public List<OptionTagOpenContext> optionTagOpen() {
6628                        return getRuleContexts(OptionTagOpenContext.class);
6629                }
6630                public OptionTagOpenContext optionTagOpen(int i) {
6631                        return getRuleContext(OptionTagOpenContext.class,i);
6632                }
6633                public List<TbodyTagOpenContext> tbodyTagOpen() {
6634                        return getRuleContexts(TbodyTagOpenContext.class);
6635                }
6636                public TbodyTagOpenContext tbodyTagOpen(int i) {
6637                        return getRuleContext(TbodyTagOpenContext.class,i);
6638                }
6639                public List<TheadTagOpenContext> theadTagOpen() {
6640                        return getRuleContexts(TheadTagOpenContext.class);
6641                }
6642                public TheadTagOpenContext theadTagOpen(int i) {
6643                        return getRuleContext(TheadTagOpenContext.class,i);
6644                }
6645                public List<TfootTagOpenContext> tfootTagOpen() {
6646                        return getRuleContexts(TfootTagOpenContext.class);
6647                }
6648                public TfootTagOpenContext tfootTagOpen(int i) {
6649                        return getRuleContext(TfootTagOpenContext.class,i);
6650                }
6651                public List<HtmlCommentContext> htmlComment() {
6652                        return getRuleContexts(HtmlCommentContext.class);
6653                }
6654                public HtmlCommentContext htmlComment(int i) {
6655                        return getRuleContext(HtmlCommentContext.class,i);
6656                }
6657                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6658                public TerminalNode CDATA(int i) {
6659                        return getToken(JavadocParser.CDATA, i);
6660                }
6661                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6662                public TerminalNode NEWLINE(int i) {
6663                        return getToken(JavadocParser.NEWLINE, i);
6664                }
6665                public List<TextContext> text() {
6666                        return getRuleContexts(TextContext.class);
6667                }
6668                public TextContext text(int i) {
6669                        return getRuleContext(TextContext.class,i);
6670                }
6671                public List<JavadocInlineTagContext> javadocInlineTag() {
6672                        return getRuleContexts(JavadocInlineTagContext.class);
6673                }
6674                public JavadocInlineTagContext javadocInlineTag(int i) {
6675                        return getRuleContext(JavadocInlineTagContext.class,i);
6676                }
6677                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6678                public TerminalNode LEADING_ASTERISK(int i) {
6679                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6680                }
6681                public DdContext(ParserRuleContext parent, int invokingState) {
6682                        super(parent, invokingState);
6683                }
6684                @Override public int getRuleIndex() { return RULE_dd; }
6685                @Override
6686                public void enterRule(ParseTreeListener listener) {
6687                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this);
6688                }
6689                @Override
6690                public void exitRule(ParseTreeListener listener) {
6691                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this);
6692                }
6693                @Override
6694                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6695                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this);
6696                        else return visitor.visitChildren(this);
6697                }
6698        }
6699
6700        public final DdContext dd() throws RecognitionException {
6701                DdContext _localctx = new DdContext(_ctx, getState());
6702                enterRule(_localctx, 58, RULE_dd);
6703                try {
6704                        int _alt;
6705                        enterOuterAlt(_localctx, 1);
6706                        {
6707                        setState(813);
6708                        ddTagOpen();
6709                        setState(853);
6710                        _errHandler.sync(this);
6711                        _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6712                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6713                                if ( _alt==1 ) {
6714                                        {
6715                                        setState(851);
6716                                        _errHandler.sync(this);
6717                                        switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
6718                                        case 1:
6719                                                {
6720                                                setState(814);
6721                                                htmlTag();
6722                                                }
6723                                                break;
6724                                        case 2:
6725                                                {
6726                                                setState(815);
6727                                                singletonTag();
6728                                                }
6729                                                break;
6730                                        case 3:
6731                                                {
6732                                                setState(816);
6733                                                paragraph();
6734                                                }
6735                                                break;
6736                                        case 4:
6737                                                {
6738                                                setState(817);
6739                                                li();
6740                                                }
6741                                                break;
6742                                        case 5:
6743                                                {
6744                                                setState(818);
6745                                                tr();
6746                                                }
6747                                                break;
6748                                        case 6:
6749                                                {
6750                                                setState(819);
6751                                                td();
6752                                                }
6753                                                break;
6754                                        case 7:
6755                                                {
6756                                                setState(820);
6757                                                th();
6758                                                }
6759                                                break;
6760                                        case 8:
6761                                                {
6762                                                setState(821);
6763                                                body();
6764                                                }
6765                                                break;
6766                                        case 9:
6767                                                {
6768                                                setState(822);
6769                                                colgroup();
6770                                                }
6771                                                break;
6772                                        case 10:
6773                                                {
6774                                                setState(823);
6775                                                dt();
6776                                                }
6777                                                break;
6778                                        case 11:
6779                                                {
6780                                                setState(824);
6781                                                head();
6782                                                }
6783                                                break;
6784                                        case 12:
6785                                                {
6786                                                setState(825);
6787                                                html();
6788                                                }
6789                                                break;
6790                                        case 13:
6791                                                {
6792                                                setState(826);
6793                                                option();
6794                                                }
6795                                                break;
6796                                        case 14:
6797                                                {
6798                                                setState(827);
6799                                                tbody();
6800                                                }
6801                                                break;
6802                                        case 15:
6803                                                {
6804                                                setState(828);
6805                                                thead();
6806                                                }
6807                                                break;
6808                                        case 16:
6809                                                {
6810                                                setState(829);
6811                                                tfoot();
6812                                                }
6813                                                break;
6814                                        case 17:
6815                                                {
6816                                                setState(830);
6817                                                pTagOpen();
6818                                                }
6819                                                break;
6820                                        case 18:
6821                                                {
6822                                                setState(831);
6823                                                liTagOpen();
6824                                                }
6825                                                break;
6826                                        case 19:
6827                                                {
6828                                                setState(832);
6829                                                trTagOpen();
6830                                                }
6831                                                break;
6832                                        case 20:
6833                                                {
6834                                                setState(833);
6835                                                tdTagOpen();
6836                                                }
6837                                                break;
6838                                        case 21:
6839                                                {
6840                                                setState(834);
6841                                                thTagOpen();
6842                                                }
6843                                                break;
6844                                        case 22:
6845                                                {
6846                                                setState(835);
6847                                                bodyTagOpen();
6848                                                }
6849                                                break;
6850                                        case 23:
6851                                                {
6852                                                setState(836);
6853                                                colgroupTagOpen();
6854                                                }
6855                                                break;
6856                                        case 24:
6857                                                {
6858                                                setState(837);
6859                                                dtTagOpen();
6860                                                }
6861                                                break;
6862                                        case 25:
6863                                                {
6864                                                setState(838);
6865                                                headTagOpen();
6866                                                }
6867                                                break;
6868                                        case 26:
6869                                                {
6870                                                setState(839);
6871                                                htmlTagOpen();
6872                                                }
6873                                                break;
6874                                        case 27:
6875                                                {
6876                                                setState(840);
6877                                                optionTagOpen();
6878                                                }
6879                                                break;
6880                                        case 28:
6881                                                {
6882                                                setState(841);
6883                                                tbodyTagOpen();
6884                                                }
6885                                                break;
6886                                        case 29:
6887                                                {
6888                                                setState(842);
6889                                                theadTagOpen();
6890                                                }
6891                                                break;
6892                                        case 30:
6893                                                {
6894                                                setState(843);
6895                                                tfootTagOpen();
6896                                                }
6897                                                break;
6898                                        case 31:
6899                                                {
6900                                                {
6901                                                setState(844);
6902                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6903                                                setState(845);
6904                                                match(LEADING_ASTERISK);
6905                                                }
6906                                                }
6907                                                break;
6908                                        case 32:
6909                                                {
6910                                                setState(846);
6911                                                htmlComment();
6912                                                }
6913                                                break;
6914                                        case 33:
6915                                                {
6916                                                setState(847);
6917                                                match(CDATA);
6918                                                }
6919                                                break;
6920                                        case 34:
6921                                                {
6922                                                setState(848);
6923                                                match(NEWLINE);
6924                                                }
6925                                                break;
6926                                        case 35:
6927                                                {
6928                                                setState(849);
6929                                                text();
6930                                                }
6931                                                break;
6932                                        case 36:
6933                                                {
6934                                                setState(850);
6935                                                javadocInlineTag();
6936                                                }
6937                                                break;
6938                                        }
6939                                        } 
6940                                }
6941                                setState(855);
6942                                _errHandler.sync(this);
6943                                _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6944                        }
6945                        setState(856);
6946                        ddTagClose();
6947                        }
6948                }
6949                catch (RecognitionException re) {
6950                        _localctx.exception = re;
6951                        _errHandler.reportError(this, re);
6952                        _errHandler.recover(this, re);
6953                }
6954                finally {
6955                        exitRule();
6956                }
6957                return _localctx;
6958        }
6959
6960        public static class DtTagOpenContext extends ParserRuleContext {
6961                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6962                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6963                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6964                public List<AttributeContext> attribute() {
6965                        return getRuleContexts(AttributeContext.class);
6966                }
6967                public AttributeContext attribute(int i) {
6968                        return getRuleContext(AttributeContext.class,i);
6969                }
6970                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6971                public TerminalNode NEWLINE(int i) {
6972                        return getToken(JavadocParser.NEWLINE, i);
6973                }
6974                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6975                public TerminalNode LEADING_ASTERISK(int i) {
6976                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6977                }
6978                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6979                public TerminalNode WS(int i) {
6980                        return getToken(JavadocParser.WS, i);
6981                }
6982                public DtTagOpenContext(ParserRuleContext parent, int invokingState) {
6983                        super(parent, invokingState);
6984                }
6985                @Override public int getRuleIndex() { return RULE_dtTagOpen; }
6986                @Override
6987                public void enterRule(ParseTreeListener listener) {
6988                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this);
6989                }
6990                @Override
6991                public void exitRule(ParseTreeListener listener) {
6992                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this);
6993                }
6994                @Override
6995                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6996                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this);
6997                        else return visitor.visitChildren(this);
6998                }
6999        }
7000
7001        public final DtTagOpenContext dtTagOpen() throws RecognitionException {
7002                DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState());
7003                enterRule(_localctx, 60, RULE_dtTagOpen);
7004                int _la;
7005                try {
7006                        enterOuterAlt(_localctx, 1);
7007                        {
7008                        setState(858);
7009                        match(OPEN);
7010                        setState(859);
7011                        match(DT_HTML_TAG_NAME);
7012                        setState(866);
7013                        _errHandler.sync(this);
7014                        _la = _input.LA(1);
7015                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7016                                {
7017                                setState(864);
7018                                _errHandler.sync(this);
7019                                switch (_input.LA(1)) {
7020                                case HTML_TAG_NAME:
7021                                        {
7022                                        setState(860);
7023                                        attribute();
7024                                        }
7025                                        break;
7026                                case NEWLINE:
7027                                        {
7028                                        setState(861);
7029                                        match(NEWLINE);
7030                                        }
7031                                        break;
7032                                case LEADING_ASTERISK:
7033                                        {
7034                                        setState(862);
7035                                        match(LEADING_ASTERISK);
7036                                        }
7037                                        break;
7038                                case WS:
7039                                        {
7040                                        setState(863);
7041                                        match(WS);
7042                                        }
7043                                        break;
7044                                default:
7045                                        throw new NoViableAltException(this);
7046                                }
7047                                }
7048                                setState(868);
7049                                _errHandler.sync(this);
7050                                _la = _input.LA(1);
7051                        }
7052                        setState(869);
7053                        match(CLOSE);
7054                        }
7055                }
7056                catch (RecognitionException re) {
7057                        _localctx.exception = re;
7058                        _errHandler.reportError(this, re);
7059                        _errHandler.recover(this, re);
7060                }
7061                finally {
7062                        exitRule();
7063                }
7064                return _localctx;
7065        }
7066
7067        public static class DtTagCloseContext extends ParserRuleContext {
7068                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7069                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7070                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
7071                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7072                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7073                public TerminalNode NEWLINE(int i) {
7074                        return getToken(JavadocParser.NEWLINE, i);
7075                }
7076                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7077                public TerminalNode LEADING_ASTERISK(int i) {
7078                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7079                }
7080                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7081                public TerminalNode WS(int i) {
7082                        return getToken(JavadocParser.WS, i);
7083                }
7084                public DtTagCloseContext(ParserRuleContext parent, int invokingState) {
7085                        super(parent, invokingState);
7086                }
7087                @Override public int getRuleIndex() { return RULE_dtTagClose; }
7088                @Override
7089                public void enterRule(ParseTreeListener listener) {
7090                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this);
7091                }
7092                @Override
7093                public void exitRule(ParseTreeListener listener) {
7094                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this);
7095                }
7096                @Override
7097                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7098                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this);
7099                        else return visitor.visitChildren(this);
7100                }
7101        }
7102
7103        public final DtTagCloseContext dtTagClose() throws RecognitionException {
7104                DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState());
7105                enterRule(_localctx, 62, RULE_dtTagClose);
7106                int _la;
7107                try {
7108                        enterOuterAlt(_localctx, 1);
7109                        {
7110                        setState(871);
7111                        match(OPEN);
7112                        setState(872);
7113                        match(SLASH);
7114                        setState(873);
7115                        match(DT_HTML_TAG_NAME);
7116                        setState(877);
7117                        _errHandler.sync(this);
7118                        _la = _input.LA(1);
7119                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7120                                {
7121                                {
7122                                setState(874);
7123                                _la = _input.LA(1);
7124                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7125                                _errHandler.recoverInline(this);
7126                                }
7127                                else {
7128                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
7129                                        _errHandler.reportMatch(this);
7130                                        consume();
7131                                }
7132                                }
7133                                }
7134                                setState(879);
7135                                _errHandler.sync(this);
7136                                _la = _input.LA(1);
7137                        }
7138                        setState(880);
7139                        match(CLOSE);
7140                        }
7141                }
7142                catch (RecognitionException re) {
7143                        _localctx.exception = re;
7144                        _errHandler.reportError(this, re);
7145                        _errHandler.recover(this, re);
7146                }
7147                finally {
7148                        exitRule();
7149                }
7150                return _localctx;
7151        }
7152
7153        public static class DtContext extends ParserRuleContext {
7154                public DtTagOpenContext dtTagOpen() {
7155                        return getRuleContext(DtTagOpenContext.class,0);
7156                }
7157                public DtTagCloseContext dtTagClose() {
7158                        return getRuleContext(DtTagCloseContext.class,0);
7159                }
7160                public List<HtmlTagContext> htmlTag() {
7161                        return getRuleContexts(HtmlTagContext.class);
7162                }
7163                public HtmlTagContext htmlTag(int i) {
7164                        return getRuleContext(HtmlTagContext.class,i);
7165                }
7166                public List<SingletonTagContext> singletonTag() {
7167                        return getRuleContexts(SingletonTagContext.class);
7168                }
7169                public SingletonTagContext singletonTag(int i) {
7170                        return getRuleContext(SingletonTagContext.class,i);
7171                }
7172                public List<ParagraphContext> paragraph() {
7173                        return getRuleContexts(ParagraphContext.class);
7174                }
7175                public ParagraphContext paragraph(int i) {
7176                        return getRuleContext(ParagraphContext.class,i);
7177                }
7178                public List<LiContext> li() {
7179                        return getRuleContexts(LiContext.class);
7180                }
7181                public LiContext li(int i) {
7182                        return getRuleContext(LiContext.class,i);
7183                }
7184                public List<TrContext> tr() {
7185                        return getRuleContexts(TrContext.class);
7186                }
7187                public TrContext tr(int i) {
7188                        return getRuleContext(TrContext.class,i);
7189                }
7190                public List<TdContext> td() {
7191                        return getRuleContexts(TdContext.class);
7192                }
7193                public TdContext td(int i) {
7194                        return getRuleContext(TdContext.class,i);
7195                }
7196                public List<ThContext> th() {
7197                        return getRuleContexts(ThContext.class);
7198                }
7199                public ThContext th(int i) {
7200                        return getRuleContext(ThContext.class,i);
7201                }
7202                public List<BodyContext> body() {
7203                        return getRuleContexts(BodyContext.class);
7204                }
7205                public BodyContext body(int i) {
7206                        return getRuleContext(BodyContext.class,i);
7207                }
7208                public List<ColgroupContext> colgroup() {
7209                        return getRuleContexts(ColgroupContext.class);
7210                }
7211                public ColgroupContext colgroup(int i) {
7212                        return getRuleContext(ColgroupContext.class,i);
7213                }
7214                public List<DdContext> dd() {
7215                        return getRuleContexts(DdContext.class);
7216                }
7217                public DdContext dd(int i) {
7218                        return getRuleContext(DdContext.class,i);
7219                }
7220                public List<HeadContext> head() {
7221                        return getRuleContexts(HeadContext.class);
7222                }
7223                public HeadContext head(int i) {
7224                        return getRuleContext(HeadContext.class,i);
7225                }
7226                public List<HtmlContext> html() {
7227                        return getRuleContexts(HtmlContext.class);
7228                }
7229                public HtmlContext html(int i) {
7230                        return getRuleContext(HtmlContext.class,i);
7231                }
7232                public List<OptionContext> option() {
7233                        return getRuleContexts(OptionContext.class);
7234                }
7235                public OptionContext option(int i) {
7236                        return getRuleContext(OptionContext.class,i);
7237                }
7238                public List<TbodyContext> tbody() {
7239                        return getRuleContexts(TbodyContext.class);
7240                }
7241                public TbodyContext tbody(int i) {
7242                        return getRuleContext(TbodyContext.class,i);
7243                }
7244                public List<TheadContext> thead() {
7245                        return getRuleContexts(TheadContext.class);
7246                }
7247                public TheadContext thead(int i) {
7248                        return getRuleContext(TheadContext.class,i);
7249                }
7250                public List<TfootContext> tfoot() {
7251                        return getRuleContexts(TfootContext.class);
7252                }
7253                public TfootContext tfoot(int i) {
7254                        return getRuleContext(TfootContext.class,i);
7255                }
7256                public List<PTagOpenContext> pTagOpen() {
7257                        return getRuleContexts(PTagOpenContext.class);
7258                }
7259                public PTagOpenContext pTagOpen(int i) {
7260                        return getRuleContext(PTagOpenContext.class,i);
7261                }
7262                public List<LiTagOpenContext> liTagOpen() {
7263                        return getRuleContexts(LiTagOpenContext.class);
7264                }
7265                public LiTagOpenContext liTagOpen(int i) {
7266                        return getRuleContext(LiTagOpenContext.class,i);
7267                }
7268                public List<TrTagOpenContext> trTagOpen() {
7269                        return getRuleContexts(TrTagOpenContext.class);
7270                }
7271                public TrTagOpenContext trTagOpen(int i) {
7272                        return getRuleContext(TrTagOpenContext.class,i);
7273                }
7274                public List<TdTagOpenContext> tdTagOpen() {
7275                        return getRuleContexts(TdTagOpenContext.class);
7276                }
7277                public TdTagOpenContext tdTagOpen(int i) {
7278                        return getRuleContext(TdTagOpenContext.class,i);
7279                }
7280                public List<ThTagOpenContext> thTagOpen() {
7281                        return getRuleContexts(ThTagOpenContext.class);
7282                }
7283                public ThTagOpenContext thTagOpen(int i) {
7284                        return getRuleContext(ThTagOpenContext.class,i);
7285                }
7286                public List<BodyTagOpenContext> bodyTagOpen() {
7287                        return getRuleContexts(BodyTagOpenContext.class);
7288                }
7289                public BodyTagOpenContext bodyTagOpen(int i) {
7290                        return getRuleContext(BodyTagOpenContext.class,i);
7291                }
7292                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7293                        return getRuleContexts(ColgroupTagOpenContext.class);
7294                }
7295                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7296                        return getRuleContext(ColgroupTagOpenContext.class,i);
7297                }
7298                public List<DdTagOpenContext> ddTagOpen() {
7299                        return getRuleContexts(DdTagOpenContext.class);
7300                }
7301                public DdTagOpenContext ddTagOpen(int i) {
7302                        return getRuleContext(DdTagOpenContext.class,i);
7303                }
7304                public List<HeadTagOpenContext> headTagOpen() {
7305                        return getRuleContexts(HeadTagOpenContext.class);
7306                }
7307                public HeadTagOpenContext headTagOpen(int i) {
7308                        return getRuleContext(HeadTagOpenContext.class,i);
7309                }
7310                public List<HtmlTagOpenContext> htmlTagOpen() {
7311                        return getRuleContexts(HtmlTagOpenContext.class);
7312                }
7313                public HtmlTagOpenContext htmlTagOpen(int i) {
7314                        return getRuleContext(HtmlTagOpenContext.class,i);
7315                }
7316                public List<OptionTagOpenContext> optionTagOpen() {
7317                        return getRuleContexts(OptionTagOpenContext.class);
7318                }
7319                public OptionTagOpenContext optionTagOpen(int i) {
7320                        return getRuleContext(OptionTagOpenContext.class,i);
7321                }
7322                public List<TbodyTagOpenContext> tbodyTagOpen() {
7323                        return getRuleContexts(TbodyTagOpenContext.class);
7324                }
7325                public TbodyTagOpenContext tbodyTagOpen(int i) {
7326                        return getRuleContext(TbodyTagOpenContext.class,i);
7327                }
7328                public List<TheadTagOpenContext> theadTagOpen() {
7329                        return getRuleContexts(TheadTagOpenContext.class);
7330                }
7331                public TheadTagOpenContext theadTagOpen(int i) {
7332                        return getRuleContext(TheadTagOpenContext.class,i);
7333                }
7334                public List<TfootTagOpenContext> tfootTagOpen() {
7335                        return getRuleContexts(TfootTagOpenContext.class);
7336                }
7337                public TfootTagOpenContext tfootTagOpen(int i) {
7338                        return getRuleContext(TfootTagOpenContext.class,i);
7339                }
7340                public List<HtmlCommentContext> htmlComment() {
7341                        return getRuleContexts(HtmlCommentContext.class);
7342                }
7343                public HtmlCommentContext htmlComment(int i) {
7344                        return getRuleContext(HtmlCommentContext.class,i);
7345                }
7346                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7347                public TerminalNode CDATA(int i) {
7348                        return getToken(JavadocParser.CDATA, i);
7349                }
7350                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7351                public TerminalNode NEWLINE(int i) {
7352                        return getToken(JavadocParser.NEWLINE, i);
7353                }
7354                public List<TextContext> text() {
7355                        return getRuleContexts(TextContext.class);
7356                }
7357                public TextContext text(int i) {
7358                        return getRuleContext(TextContext.class,i);
7359                }
7360                public List<JavadocInlineTagContext> javadocInlineTag() {
7361                        return getRuleContexts(JavadocInlineTagContext.class);
7362                }
7363                public JavadocInlineTagContext javadocInlineTag(int i) {
7364                        return getRuleContext(JavadocInlineTagContext.class,i);
7365                }
7366                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7367                public TerminalNode LEADING_ASTERISK(int i) {
7368                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7369                }
7370                public DtContext(ParserRuleContext parent, int invokingState) {
7371                        super(parent, invokingState);
7372                }
7373                @Override public int getRuleIndex() { return RULE_dt; }
7374                @Override
7375                public void enterRule(ParseTreeListener listener) {
7376                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this);
7377                }
7378                @Override
7379                public void exitRule(ParseTreeListener listener) {
7380                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this);
7381                }
7382                @Override
7383                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7384                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this);
7385                        else return visitor.visitChildren(this);
7386                }
7387        }
7388
7389        public final DtContext dt() throws RecognitionException {
7390                DtContext _localctx = new DtContext(_ctx, getState());
7391                enterRule(_localctx, 64, RULE_dt);
7392                try {
7393                        int _alt;
7394                        enterOuterAlt(_localctx, 1);
7395                        {
7396                        setState(882);
7397                        dtTagOpen();
7398                        setState(922);
7399                        _errHandler.sync(this);
7400                        _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7401                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7402                                if ( _alt==1 ) {
7403                                        {
7404                                        setState(920);
7405                                        _errHandler.sync(this);
7406                                        switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
7407                                        case 1:
7408                                                {
7409                                                setState(883);
7410                                                htmlTag();
7411                                                }
7412                                                break;
7413                                        case 2:
7414                                                {
7415                                                setState(884);
7416                                                singletonTag();
7417                                                }
7418                                                break;
7419                                        case 3:
7420                                                {
7421                                                setState(885);
7422                                                paragraph();
7423                                                }
7424                                                break;
7425                                        case 4:
7426                                                {
7427                                                setState(886);
7428                                                li();
7429                                                }
7430                                                break;
7431                                        case 5:
7432                                                {
7433                                                setState(887);
7434                                                tr();
7435                                                }
7436                                                break;
7437                                        case 6:
7438                                                {
7439                                                setState(888);
7440                                                td();
7441                                                }
7442                                                break;
7443                                        case 7:
7444                                                {
7445                                                setState(889);
7446                                                th();
7447                                                }
7448                                                break;
7449                                        case 8:
7450                                                {
7451                                                setState(890);
7452                                                body();
7453                                                }
7454                                                break;
7455                                        case 9:
7456                                                {
7457                                                setState(891);
7458                                                colgroup();
7459                                                }
7460                                                break;
7461                                        case 10:
7462                                                {
7463                                                setState(892);
7464                                                dd();
7465                                                }
7466                                                break;
7467                                        case 11:
7468                                                {
7469                                                setState(893);
7470                                                head();
7471                                                }
7472                                                break;
7473                                        case 12:
7474                                                {
7475                                                setState(894);
7476                                                html();
7477                                                }
7478                                                break;
7479                                        case 13:
7480                                                {
7481                                                setState(895);
7482                                                option();
7483                                                }
7484                                                break;
7485                                        case 14:
7486                                                {
7487                                                setState(896);
7488                                                tbody();
7489                                                }
7490                                                break;
7491                                        case 15:
7492                                                {
7493                                                setState(897);
7494                                                thead();
7495                                                }
7496                                                break;
7497                                        case 16:
7498                                                {
7499                                                setState(898);
7500                                                tfoot();
7501                                                }
7502                                                break;
7503                                        case 17:
7504                                                {
7505                                                setState(899);
7506                                                pTagOpen();
7507                                                }
7508                                                break;
7509                                        case 18:
7510                                                {
7511                                                setState(900);
7512                                                liTagOpen();
7513                                                }
7514                                                break;
7515                                        case 19:
7516                                                {
7517                                                setState(901);
7518                                                trTagOpen();
7519                                                }
7520                                                break;
7521                                        case 20:
7522                                                {
7523                                                setState(902);
7524                                                tdTagOpen();
7525                                                }
7526                                                break;
7527                                        case 21:
7528                                                {
7529                                                setState(903);
7530                                                thTagOpen();
7531                                                }
7532                                                break;
7533                                        case 22:
7534                                                {
7535                                                setState(904);
7536                                                bodyTagOpen();
7537                                                }
7538                                                break;
7539                                        case 23:
7540                                                {
7541                                                setState(905);
7542                                                colgroupTagOpen();
7543                                                }
7544                                                break;
7545                                        case 24:
7546                                                {
7547                                                setState(906);
7548                                                ddTagOpen();
7549                                                }
7550                                                break;
7551                                        case 25:
7552                                                {
7553                                                setState(907);
7554                                                headTagOpen();
7555                                                }
7556                                                break;
7557                                        case 26:
7558                                                {
7559                                                setState(908);
7560                                                htmlTagOpen();
7561                                                }
7562                                                break;
7563                                        case 27:
7564                                                {
7565                                                setState(909);
7566                                                optionTagOpen();
7567                                                }
7568                                                break;
7569                                        case 28:
7570                                                {
7571                                                setState(910);
7572                                                tbodyTagOpen();
7573                                                }
7574                                                break;
7575                                        case 29:
7576                                                {
7577                                                setState(911);
7578                                                theadTagOpen();
7579                                                }
7580                                                break;
7581                                        case 30:
7582                                                {
7583                                                setState(912);
7584                                                tfootTagOpen();
7585                                                }
7586                                                break;
7587                                        case 31:
7588                                                {
7589                                                {
7590                                                setState(913);
7591                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7592                                                setState(914);
7593                                                match(LEADING_ASTERISK);
7594                                                }
7595                                                }
7596                                                break;
7597                                        case 32:
7598                                                {
7599                                                setState(915);
7600                                                htmlComment();
7601                                                }
7602                                                break;
7603                                        case 33:
7604                                                {
7605                                                setState(916);
7606                                                match(CDATA);
7607                                                }
7608                                                break;
7609                                        case 34:
7610                                                {
7611                                                setState(917);
7612                                                match(NEWLINE);
7613                                                }
7614                                                break;
7615                                        case 35:
7616                                                {
7617                                                setState(918);
7618                                                text();
7619                                                }
7620                                                break;
7621                                        case 36:
7622                                                {
7623                                                setState(919);
7624                                                javadocInlineTag();
7625                                                }
7626                                                break;
7627                                        }
7628                                        } 
7629                                }
7630                                setState(924);
7631                                _errHandler.sync(this);
7632                                _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7633                        }
7634                        setState(925);
7635                        dtTagClose();
7636                        }
7637                }
7638                catch (RecognitionException re) {
7639                        _localctx.exception = re;
7640                        _errHandler.reportError(this, re);
7641                        _errHandler.recover(this, re);
7642                }
7643                finally {
7644                        exitRule();
7645                }
7646                return _localctx;
7647        }
7648
7649        public static class HeadTagOpenContext extends ParserRuleContext {
7650                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7651                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7652                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7653                public List<AttributeContext> attribute() {
7654                        return getRuleContexts(AttributeContext.class);
7655                }
7656                public AttributeContext attribute(int i) {
7657                        return getRuleContext(AttributeContext.class,i);
7658                }
7659                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7660                public TerminalNode NEWLINE(int i) {
7661                        return getToken(JavadocParser.NEWLINE, i);
7662                }
7663                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7664                public TerminalNode LEADING_ASTERISK(int i) {
7665                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7666                }
7667                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7668                public TerminalNode WS(int i) {
7669                        return getToken(JavadocParser.WS, i);
7670                }
7671                public HeadTagOpenContext(ParserRuleContext parent, int invokingState) {
7672                        super(parent, invokingState);
7673                }
7674                @Override public int getRuleIndex() { return RULE_headTagOpen; }
7675                @Override
7676                public void enterRule(ParseTreeListener listener) {
7677                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this);
7678                }
7679                @Override
7680                public void exitRule(ParseTreeListener listener) {
7681                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this);
7682                }
7683                @Override
7684                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7685                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this);
7686                        else return visitor.visitChildren(this);
7687                }
7688        }
7689
7690        public final HeadTagOpenContext headTagOpen() throws RecognitionException {
7691                HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState());
7692                enterRule(_localctx, 66, RULE_headTagOpen);
7693                int _la;
7694                try {
7695                        enterOuterAlt(_localctx, 1);
7696                        {
7697                        setState(927);
7698                        match(OPEN);
7699                        setState(928);
7700                        match(HEAD_HTML_TAG_NAME);
7701                        setState(935);
7702                        _errHandler.sync(this);
7703                        _la = _input.LA(1);
7704                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7705                                {
7706                                setState(933);
7707                                _errHandler.sync(this);
7708                                switch (_input.LA(1)) {
7709                                case HTML_TAG_NAME:
7710                                        {
7711                                        setState(929);
7712                                        attribute();
7713                                        }
7714                                        break;
7715                                case NEWLINE:
7716                                        {
7717                                        setState(930);
7718                                        match(NEWLINE);
7719                                        }
7720                                        break;
7721                                case LEADING_ASTERISK:
7722                                        {
7723                                        setState(931);
7724                                        match(LEADING_ASTERISK);
7725                                        }
7726                                        break;
7727                                case WS:
7728                                        {
7729                                        setState(932);
7730                                        match(WS);
7731                                        }
7732                                        break;
7733                                default:
7734                                        throw new NoViableAltException(this);
7735                                }
7736                                }
7737                                setState(937);
7738                                _errHandler.sync(this);
7739                                _la = _input.LA(1);
7740                        }
7741                        setState(938);
7742                        match(CLOSE);
7743                        }
7744                }
7745                catch (RecognitionException re) {
7746                        _localctx.exception = re;
7747                        _errHandler.reportError(this, re);
7748                        _errHandler.recover(this, re);
7749                }
7750                finally {
7751                        exitRule();
7752                }
7753                return _localctx;
7754        }
7755
7756        public static class HeadTagCloseContext extends ParserRuleContext {
7757                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7758                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7759                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7760                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7761                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7762                public TerminalNode NEWLINE(int i) {
7763                        return getToken(JavadocParser.NEWLINE, i);
7764                }
7765                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7766                public TerminalNode LEADING_ASTERISK(int i) {
7767                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7768                }
7769                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7770                public TerminalNode WS(int i) {
7771                        return getToken(JavadocParser.WS, i);
7772                }
7773                public HeadTagCloseContext(ParserRuleContext parent, int invokingState) {
7774                        super(parent, invokingState);
7775                }
7776                @Override public int getRuleIndex() { return RULE_headTagClose; }
7777                @Override
7778                public void enterRule(ParseTreeListener listener) {
7779                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this);
7780                }
7781                @Override
7782                public void exitRule(ParseTreeListener listener) {
7783                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this);
7784                }
7785                @Override
7786                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7787                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this);
7788                        else return visitor.visitChildren(this);
7789                }
7790        }
7791
7792        public final HeadTagCloseContext headTagClose() throws RecognitionException {
7793                HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState());
7794                enterRule(_localctx, 68, RULE_headTagClose);
7795                int _la;
7796                try {
7797                        enterOuterAlt(_localctx, 1);
7798                        {
7799                        setState(940);
7800                        match(OPEN);
7801                        setState(941);
7802                        match(SLASH);
7803                        setState(942);
7804                        match(HEAD_HTML_TAG_NAME);
7805                        setState(946);
7806                        _errHandler.sync(this);
7807                        _la = _input.LA(1);
7808                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7809                                {
7810                                {
7811                                setState(943);
7812                                _la = _input.LA(1);
7813                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7814                                _errHandler.recoverInline(this);
7815                                }
7816                                else {
7817                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
7818                                        _errHandler.reportMatch(this);
7819                                        consume();
7820                                }
7821                                }
7822                                }
7823                                setState(948);
7824                                _errHandler.sync(this);
7825                                _la = _input.LA(1);
7826                        }
7827                        setState(949);
7828                        match(CLOSE);
7829                        }
7830                }
7831                catch (RecognitionException re) {
7832                        _localctx.exception = re;
7833                        _errHandler.reportError(this, re);
7834                        _errHandler.recover(this, re);
7835                }
7836                finally {
7837                        exitRule();
7838                }
7839                return _localctx;
7840        }
7841
7842        public static class HeadContext extends ParserRuleContext {
7843                public HeadTagOpenContext headTagOpen() {
7844                        return getRuleContext(HeadTagOpenContext.class,0);
7845                }
7846                public HeadTagCloseContext headTagClose() {
7847                        return getRuleContext(HeadTagCloseContext.class,0);
7848                }
7849                public List<HtmlTagContext> htmlTag() {
7850                        return getRuleContexts(HtmlTagContext.class);
7851                }
7852                public HtmlTagContext htmlTag(int i) {
7853                        return getRuleContext(HtmlTagContext.class,i);
7854                }
7855                public List<SingletonTagContext> singletonTag() {
7856                        return getRuleContexts(SingletonTagContext.class);
7857                }
7858                public SingletonTagContext singletonTag(int i) {
7859                        return getRuleContext(SingletonTagContext.class,i);
7860                }
7861                public List<ParagraphContext> paragraph() {
7862                        return getRuleContexts(ParagraphContext.class);
7863                }
7864                public ParagraphContext paragraph(int i) {
7865                        return getRuleContext(ParagraphContext.class,i);
7866                }
7867                public List<LiContext> li() {
7868                        return getRuleContexts(LiContext.class);
7869                }
7870                public LiContext li(int i) {
7871                        return getRuleContext(LiContext.class,i);
7872                }
7873                public List<TrContext> tr() {
7874                        return getRuleContexts(TrContext.class);
7875                }
7876                public TrContext tr(int i) {
7877                        return getRuleContext(TrContext.class,i);
7878                }
7879                public List<TdContext> td() {
7880                        return getRuleContexts(TdContext.class);
7881                }
7882                public TdContext td(int i) {
7883                        return getRuleContext(TdContext.class,i);
7884                }
7885                public List<ThContext> th() {
7886                        return getRuleContexts(ThContext.class);
7887                }
7888                public ThContext th(int i) {
7889                        return getRuleContext(ThContext.class,i);
7890                }
7891                public List<BodyContext> body() {
7892                        return getRuleContexts(BodyContext.class);
7893                }
7894                public BodyContext body(int i) {
7895                        return getRuleContext(BodyContext.class,i);
7896                }
7897                public List<ColgroupContext> colgroup() {
7898                        return getRuleContexts(ColgroupContext.class);
7899                }
7900                public ColgroupContext colgroup(int i) {
7901                        return getRuleContext(ColgroupContext.class,i);
7902                }
7903                public List<DdContext> dd() {
7904                        return getRuleContexts(DdContext.class);
7905                }
7906                public DdContext dd(int i) {
7907                        return getRuleContext(DdContext.class,i);
7908                }
7909                public List<DtContext> dt() {
7910                        return getRuleContexts(DtContext.class);
7911                }
7912                public DtContext dt(int i) {
7913                        return getRuleContext(DtContext.class,i);
7914                }
7915                public List<HtmlContext> html() {
7916                        return getRuleContexts(HtmlContext.class);
7917                }
7918                public HtmlContext html(int i) {
7919                        return getRuleContext(HtmlContext.class,i);
7920                }
7921                public List<OptionContext> option() {
7922                        return getRuleContexts(OptionContext.class);
7923                }
7924                public OptionContext option(int i) {
7925                        return getRuleContext(OptionContext.class,i);
7926                }
7927                public List<TbodyContext> tbody() {
7928                        return getRuleContexts(TbodyContext.class);
7929                }
7930                public TbodyContext tbody(int i) {
7931                        return getRuleContext(TbodyContext.class,i);
7932                }
7933                public List<TheadContext> thead() {
7934                        return getRuleContexts(TheadContext.class);
7935                }
7936                public TheadContext thead(int i) {
7937                        return getRuleContext(TheadContext.class,i);
7938                }
7939                public List<TfootContext> tfoot() {
7940                        return getRuleContexts(TfootContext.class);
7941                }
7942                public TfootContext tfoot(int i) {
7943                        return getRuleContext(TfootContext.class,i);
7944                }
7945                public List<PTagOpenContext> pTagOpen() {
7946                        return getRuleContexts(PTagOpenContext.class);
7947                }
7948                public PTagOpenContext pTagOpen(int i) {
7949                        return getRuleContext(PTagOpenContext.class,i);
7950                }
7951                public List<LiTagOpenContext> liTagOpen() {
7952                        return getRuleContexts(LiTagOpenContext.class);
7953                }
7954                public LiTagOpenContext liTagOpen(int i) {
7955                        return getRuleContext(LiTagOpenContext.class,i);
7956                }
7957                public List<TrTagOpenContext> trTagOpen() {
7958                        return getRuleContexts(TrTagOpenContext.class);
7959                }
7960                public TrTagOpenContext trTagOpen(int i) {
7961                        return getRuleContext(TrTagOpenContext.class,i);
7962                }
7963                public List<TdTagOpenContext> tdTagOpen() {
7964                        return getRuleContexts(TdTagOpenContext.class);
7965                }
7966                public TdTagOpenContext tdTagOpen(int i) {
7967                        return getRuleContext(TdTagOpenContext.class,i);
7968                }
7969                public List<ThTagOpenContext> thTagOpen() {
7970                        return getRuleContexts(ThTagOpenContext.class);
7971                }
7972                public ThTagOpenContext thTagOpen(int i) {
7973                        return getRuleContext(ThTagOpenContext.class,i);
7974                }
7975                public List<BodyTagOpenContext> bodyTagOpen() {
7976                        return getRuleContexts(BodyTagOpenContext.class);
7977                }
7978                public BodyTagOpenContext bodyTagOpen(int i) {
7979                        return getRuleContext(BodyTagOpenContext.class,i);
7980                }
7981                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7982                        return getRuleContexts(ColgroupTagOpenContext.class);
7983                }
7984                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7985                        return getRuleContext(ColgroupTagOpenContext.class,i);
7986                }
7987                public List<DdTagOpenContext> ddTagOpen() {
7988                        return getRuleContexts(DdTagOpenContext.class);
7989                }
7990                public DdTagOpenContext ddTagOpen(int i) {
7991                        return getRuleContext(DdTagOpenContext.class,i);
7992                }
7993                public List<DtTagOpenContext> dtTagOpen() {
7994                        return getRuleContexts(DtTagOpenContext.class);
7995                }
7996                public DtTagOpenContext dtTagOpen(int i) {
7997                        return getRuleContext(DtTagOpenContext.class,i);
7998                }
7999                public List<HtmlTagOpenContext> htmlTagOpen() {
8000                        return getRuleContexts(HtmlTagOpenContext.class);
8001                }
8002                public HtmlTagOpenContext htmlTagOpen(int i) {
8003                        return getRuleContext(HtmlTagOpenContext.class,i);
8004                }
8005                public List<OptionTagOpenContext> optionTagOpen() {
8006                        return getRuleContexts(OptionTagOpenContext.class);
8007                }
8008                public OptionTagOpenContext optionTagOpen(int i) {
8009                        return getRuleContext(OptionTagOpenContext.class,i);
8010                }
8011                public List<TbodyTagOpenContext> tbodyTagOpen() {
8012                        return getRuleContexts(TbodyTagOpenContext.class);
8013                }
8014                public TbodyTagOpenContext tbodyTagOpen(int i) {
8015                        return getRuleContext(TbodyTagOpenContext.class,i);
8016                }
8017                public List<TheadTagOpenContext> theadTagOpen() {
8018                        return getRuleContexts(TheadTagOpenContext.class);
8019                }
8020                public TheadTagOpenContext theadTagOpen(int i) {
8021                        return getRuleContext(TheadTagOpenContext.class,i);
8022                }
8023                public List<TfootTagOpenContext> tfootTagOpen() {
8024                        return getRuleContexts(TfootTagOpenContext.class);
8025                }
8026                public TfootTagOpenContext tfootTagOpen(int i) {
8027                        return getRuleContext(TfootTagOpenContext.class,i);
8028                }
8029                public List<HtmlCommentContext> htmlComment() {
8030                        return getRuleContexts(HtmlCommentContext.class);
8031                }
8032                public HtmlCommentContext htmlComment(int i) {
8033                        return getRuleContext(HtmlCommentContext.class,i);
8034                }
8035                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8036                public TerminalNode CDATA(int i) {
8037                        return getToken(JavadocParser.CDATA, i);
8038                }
8039                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8040                public TerminalNode NEWLINE(int i) {
8041                        return getToken(JavadocParser.NEWLINE, i);
8042                }
8043                public List<TextContext> text() {
8044                        return getRuleContexts(TextContext.class);
8045                }
8046                public TextContext text(int i) {
8047                        return getRuleContext(TextContext.class,i);
8048                }
8049                public List<JavadocInlineTagContext> javadocInlineTag() {
8050                        return getRuleContexts(JavadocInlineTagContext.class);
8051                }
8052                public JavadocInlineTagContext javadocInlineTag(int i) {
8053                        return getRuleContext(JavadocInlineTagContext.class,i);
8054                }
8055                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8056                public TerminalNode LEADING_ASTERISK(int i) {
8057                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8058                }
8059                public HeadContext(ParserRuleContext parent, int invokingState) {
8060                        super(parent, invokingState);
8061                }
8062                @Override public int getRuleIndex() { return RULE_head; }
8063                @Override
8064                public void enterRule(ParseTreeListener listener) {
8065                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this);
8066                }
8067                @Override
8068                public void exitRule(ParseTreeListener listener) {
8069                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this);
8070                }
8071                @Override
8072                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8073                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this);
8074                        else return visitor.visitChildren(this);
8075                }
8076        }
8077
8078        public final HeadContext head() throws RecognitionException {
8079                HeadContext _localctx = new HeadContext(_ctx, getState());
8080                enterRule(_localctx, 70, RULE_head);
8081                try {
8082                        int _alt;
8083                        enterOuterAlt(_localctx, 1);
8084                        {
8085                        setState(951);
8086                        headTagOpen();
8087                        setState(991);
8088                        _errHandler.sync(this);
8089                        _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8090                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8091                                if ( _alt==1 ) {
8092                                        {
8093                                        setState(989);
8094                                        _errHandler.sync(this);
8095                                        switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
8096                                        case 1:
8097                                                {
8098                                                setState(952);
8099                                                htmlTag();
8100                                                }
8101                                                break;
8102                                        case 2:
8103                                                {
8104                                                setState(953);
8105                                                singletonTag();
8106                                                }
8107                                                break;
8108                                        case 3:
8109                                                {
8110                                                setState(954);
8111                                                paragraph();
8112                                                }
8113                                                break;
8114                                        case 4:
8115                                                {
8116                                                setState(955);
8117                                                li();
8118                                                }
8119                                                break;
8120                                        case 5:
8121                                                {
8122                                                setState(956);
8123                                                tr();
8124                                                }
8125                                                break;
8126                                        case 6:
8127                                                {
8128                                                setState(957);
8129                                                td();
8130                                                }
8131                                                break;
8132                                        case 7:
8133                                                {
8134                                                setState(958);
8135                                                th();
8136                                                }
8137                                                break;
8138                                        case 8:
8139                                                {
8140                                                setState(959);
8141                                                body();
8142                                                }
8143                                                break;
8144                                        case 9:
8145                                                {
8146                                                setState(960);
8147                                                colgroup();
8148                                                }
8149                                                break;
8150                                        case 10:
8151                                                {
8152                                                setState(961);
8153                                                dd();
8154                                                }
8155                                                break;
8156                                        case 11:
8157                                                {
8158                                                setState(962);
8159                                                dt();
8160                                                }
8161                                                break;
8162                                        case 12:
8163                                                {
8164                                                setState(963);
8165                                                html();
8166                                                }
8167                                                break;
8168                                        case 13:
8169                                                {
8170                                                setState(964);
8171                                                option();
8172                                                }
8173                                                break;
8174                                        case 14:
8175                                                {
8176                                                setState(965);
8177                                                tbody();
8178                                                }
8179                                                break;
8180                                        case 15:
8181                                                {
8182                                                setState(966);
8183                                                thead();
8184                                                }
8185                                                break;
8186                                        case 16:
8187                                                {
8188                                                setState(967);
8189                                                tfoot();
8190                                                }
8191                                                break;
8192                                        case 17:
8193                                                {
8194                                                setState(968);
8195                                                pTagOpen();
8196                                                }
8197                                                break;
8198                                        case 18:
8199                                                {
8200                                                setState(969);
8201                                                liTagOpen();
8202                                                }
8203                                                break;
8204                                        case 19:
8205                                                {
8206                                                setState(970);
8207                                                trTagOpen();
8208                                                }
8209                                                break;
8210                                        case 20:
8211                                                {
8212                                                setState(971);
8213                                                tdTagOpen();
8214                                                }
8215                                                break;
8216                                        case 21:
8217                                                {
8218                                                setState(972);
8219                                                thTagOpen();
8220                                                }
8221                                                break;
8222                                        case 22:
8223                                                {
8224                                                setState(973);
8225                                                bodyTagOpen();
8226                                                }
8227                                                break;
8228                                        case 23:
8229                                                {
8230                                                setState(974);
8231                                                colgroupTagOpen();
8232                                                }
8233                                                break;
8234                                        case 24:
8235                                                {
8236                                                setState(975);
8237                                                ddTagOpen();
8238                                                }
8239                                                break;
8240                                        case 25:
8241                                                {
8242                                                setState(976);
8243                                                dtTagOpen();
8244                                                }
8245                                                break;
8246                                        case 26:
8247                                                {
8248                                                setState(977);
8249                                                htmlTagOpen();
8250                                                }
8251                                                break;
8252                                        case 27:
8253                                                {
8254                                                setState(978);
8255                                                optionTagOpen();
8256                                                }
8257                                                break;
8258                                        case 28:
8259                                                {
8260                                                setState(979);
8261                                                tbodyTagOpen();
8262                                                }
8263                                                break;
8264                                        case 29:
8265                                                {
8266                                                setState(980);
8267                                                theadTagOpen();
8268                                                }
8269                                                break;
8270                                        case 30:
8271                                                {
8272                                                setState(981);
8273                                                tfootTagOpen();
8274                                                }
8275                                                break;
8276                                        case 31:
8277                                                {
8278                                                {
8279                                                setState(982);
8280                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8281                                                setState(983);
8282                                                match(LEADING_ASTERISK);
8283                                                }
8284                                                }
8285                                                break;
8286                                        case 32:
8287                                                {
8288                                                setState(984);
8289                                                htmlComment();
8290                                                }
8291                                                break;
8292                                        case 33:
8293                                                {
8294                                                setState(985);
8295                                                match(CDATA);
8296                                                }
8297                                                break;
8298                                        case 34:
8299                                                {
8300                                                setState(986);
8301                                                match(NEWLINE);
8302                                                }
8303                                                break;
8304                                        case 35:
8305                                                {
8306                                                setState(987);
8307                                                text();
8308                                                }
8309                                                break;
8310                                        case 36:
8311                                                {
8312                                                setState(988);
8313                                                javadocInlineTag();
8314                                                }
8315                                                break;
8316                                        }
8317                                        } 
8318                                }
8319                                setState(993);
8320                                _errHandler.sync(this);
8321                                _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8322                        }
8323                        setState(994);
8324                        headTagClose();
8325                        }
8326                }
8327                catch (RecognitionException re) {
8328                        _localctx.exception = re;
8329                        _errHandler.reportError(this, re);
8330                        _errHandler.recover(this, re);
8331                }
8332                finally {
8333                        exitRule();
8334                }
8335                return _localctx;
8336        }
8337
8338        public static class HtmlTagOpenContext extends ParserRuleContext {
8339                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8340                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8341                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8342                public List<AttributeContext> attribute() {
8343                        return getRuleContexts(AttributeContext.class);
8344                }
8345                public AttributeContext attribute(int i) {
8346                        return getRuleContext(AttributeContext.class,i);
8347                }
8348                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8349                public TerminalNode NEWLINE(int i) {
8350                        return getToken(JavadocParser.NEWLINE, i);
8351                }
8352                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8353                public TerminalNode LEADING_ASTERISK(int i) {
8354                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8355                }
8356                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8357                public TerminalNode WS(int i) {
8358                        return getToken(JavadocParser.WS, i);
8359                }
8360                public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) {
8361                        super(parent, invokingState);
8362                }
8363                @Override public int getRuleIndex() { return RULE_htmlTagOpen; }
8364                @Override
8365                public void enterRule(ParseTreeListener listener) {
8366                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this);
8367                }
8368                @Override
8369                public void exitRule(ParseTreeListener listener) {
8370                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this);
8371                }
8372                @Override
8373                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8374                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this);
8375                        else return visitor.visitChildren(this);
8376                }
8377        }
8378
8379        public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException {
8380                HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState());
8381                enterRule(_localctx, 72, RULE_htmlTagOpen);
8382                int _la;
8383                try {
8384                        enterOuterAlt(_localctx, 1);
8385                        {
8386                        setState(996);
8387                        match(OPEN);
8388                        setState(997);
8389                        match(HTML_HTML_TAG_NAME);
8390                        setState(1004);
8391                        _errHandler.sync(this);
8392                        _la = _input.LA(1);
8393                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8394                                {
8395                                setState(1002);
8396                                _errHandler.sync(this);
8397                                switch (_input.LA(1)) {
8398                                case HTML_TAG_NAME:
8399                                        {
8400                                        setState(998);
8401                                        attribute();
8402                                        }
8403                                        break;
8404                                case NEWLINE:
8405                                        {
8406                                        setState(999);
8407                                        match(NEWLINE);
8408                                        }
8409                                        break;
8410                                case LEADING_ASTERISK:
8411                                        {
8412                                        setState(1000);
8413                                        match(LEADING_ASTERISK);
8414                                        }
8415                                        break;
8416                                case WS:
8417                                        {
8418                                        setState(1001);
8419                                        match(WS);
8420                                        }
8421                                        break;
8422                                default:
8423                                        throw new NoViableAltException(this);
8424                                }
8425                                }
8426                                setState(1006);
8427                                _errHandler.sync(this);
8428                                _la = _input.LA(1);
8429                        }
8430                        setState(1007);
8431                        match(CLOSE);
8432                        }
8433                }
8434                catch (RecognitionException re) {
8435                        _localctx.exception = re;
8436                        _errHandler.reportError(this, re);
8437                        _errHandler.recover(this, re);
8438                }
8439                finally {
8440                        exitRule();
8441                }
8442                return _localctx;
8443        }
8444
8445        public static class HtmlTagCloseContext extends ParserRuleContext {
8446                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8447                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8448                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8449                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8450                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8451                public TerminalNode NEWLINE(int i) {
8452                        return getToken(JavadocParser.NEWLINE, i);
8453                }
8454                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8455                public TerminalNode LEADING_ASTERISK(int i) {
8456                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8457                }
8458                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8459                public TerminalNode WS(int i) {
8460                        return getToken(JavadocParser.WS, i);
8461                }
8462                public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) {
8463                        super(parent, invokingState);
8464                }
8465                @Override public int getRuleIndex() { return RULE_htmlTagClose; }
8466                @Override
8467                public void enterRule(ParseTreeListener listener) {
8468                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this);
8469                }
8470                @Override
8471                public void exitRule(ParseTreeListener listener) {
8472                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this);
8473                }
8474                @Override
8475                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8476                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this);
8477                        else return visitor.visitChildren(this);
8478                }
8479        }
8480
8481        public final HtmlTagCloseContext htmlTagClose() throws RecognitionException {
8482                HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState());
8483                enterRule(_localctx, 74, RULE_htmlTagClose);
8484                int _la;
8485                try {
8486                        enterOuterAlt(_localctx, 1);
8487                        {
8488                        setState(1009);
8489                        match(OPEN);
8490                        setState(1010);
8491                        match(SLASH);
8492                        setState(1011);
8493                        match(HTML_HTML_TAG_NAME);
8494                        setState(1015);
8495                        _errHandler.sync(this);
8496                        _la = _input.LA(1);
8497                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8498                                {
8499                                {
8500                                setState(1012);
8501                                _la = _input.LA(1);
8502                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8503                                _errHandler.recoverInline(this);
8504                                }
8505                                else {
8506                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
8507                                        _errHandler.reportMatch(this);
8508                                        consume();
8509                                }
8510                                }
8511                                }
8512                                setState(1017);
8513                                _errHandler.sync(this);
8514                                _la = _input.LA(1);
8515                        }
8516                        setState(1018);
8517                        match(CLOSE);
8518                        }
8519                }
8520                catch (RecognitionException re) {
8521                        _localctx.exception = re;
8522                        _errHandler.reportError(this, re);
8523                        _errHandler.recover(this, re);
8524                }
8525                finally {
8526                        exitRule();
8527                }
8528                return _localctx;
8529        }
8530
8531        public static class HtmlContext extends ParserRuleContext {
8532                public HtmlTagOpenContext htmlTagOpen() {
8533                        return getRuleContext(HtmlTagOpenContext.class,0);
8534                }
8535                public HtmlTagCloseContext htmlTagClose() {
8536                        return getRuleContext(HtmlTagCloseContext.class,0);
8537                }
8538                public List<HtmlTagContext> htmlTag() {
8539                        return getRuleContexts(HtmlTagContext.class);
8540                }
8541                public HtmlTagContext htmlTag(int i) {
8542                        return getRuleContext(HtmlTagContext.class,i);
8543                }
8544                public List<SingletonTagContext> singletonTag() {
8545                        return getRuleContexts(SingletonTagContext.class);
8546                }
8547                public SingletonTagContext singletonTag(int i) {
8548                        return getRuleContext(SingletonTagContext.class,i);
8549                }
8550                public List<ParagraphContext> paragraph() {
8551                        return getRuleContexts(ParagraphContext.class);
8552                }
8553                public ParagraphContext paragraph(int i) {
8554                        return getRuleContext(ParagraphContext.class,i);
8555                }
8556                public List<LiContext> li() {
8557                        return getRuleContexts(LiContext.class);
8558                }
8559                public LiContext li(int i) {
8560                        return getRuleContext(LiContext.class,i);
8561                }
8562                public List<TrContext> tr() {
8563                        return getRuleContexts(TrContext.class);
8564                }
8565                public TrContext tr(int i) {
8566                        return getRuleContext(TrContext.class,i);
8567                }
8568                public List<TdContext> td() {
8569                        return getRuleContexts(TdContext.class);
8570                }
8571                public TdContext td(int i) {
8572                        return getRuleContext(TdContext.class,i);
8573                }
8574                public List<ThContext> th() {
8575                        return getRuleContexts(ThContext.class);
8576                }
8577                public ThContext th(int i) {
8578                        return getRuleContext(ThContext.class,i);
8579                }
8580                public List<BodyContext> body() {
8581                        return getRuleContexts(BodyContext.class);
8582                }
8583                public BodyContext body(int i) {
8584                        return getRuleContext(BodyContext.class,i);
8585                }
8586                public List<ColgroupContext> colgroup() {
8587                        return getRuleContexts(ColgroupContext.class);
8588                }
8589                public ColgroupContext colgroup(int i) {
8590                        return getRuleContext(ColgroupContext.class,i);
8591                }
8592                public List<DdContext> dd() {
8593                        return getRuleContexts(DdContext.class);
8594                }
8595                public DdContext dd(int i) {
8596                        return getRuleContext(DdContext.class,i);
8597                }
8598                public List<DtContext> dt() {
8599                        return getRuleContexts(DtContext.class);
8600                }
8601                public DtContext dt(int i) {
8602                        return getRuleContext(DtContext.class,i);
8603                }
8604                public List<HeadContext> head() {
8605                        return getRuleContexts(HeadContext.class);
8606                }
8607                public HeadContext head(int i) {
8608                        return getRuleContext(HeadContext.class,i);
8609                }
8610                public List<OptionContext> option() {
8611                        return getRuleContexts(OptionContext.class);
8612                }
8613                public OptionContext option(int i) {
8614                        return getRuleContext(OptionContext.class,i);
8615                }
8616                public List<TbodyContext> tbody() {
8617                        return getRuleContexts(TbodyContext.class);
8618                }
8619                public TbodyContext tbody(int i) {
8620                        return getRuleContext(TbodyContext.class,i);
8621                }
8622                public List<TheadContext> thead() {
8623                        return getRuleContexts(TheadContext.class);
8624                }
8625                public TheadContext thead(int i) {
8626                        return getRuleContext(TheadContext.class,i);
8627                }
8628                public List<TfootContext> tfoot() {
8629                        return getRuleContexts(TfootContext.class);
8630                }
8631                public TfootContext tfoot(int i) {
8632                        return getRuleContext(TfootContext.class,i);
8633                }
8634                public List<PTagOpenContext> pTagOpen() {
8635                        return getRuleContexts(PTagOpenContext.class);
8636                }
8637                public PTagOpenContext pTagOpen(int i) {
8638                        return getRuleContext(PTagOpenContext.class,i);
8639                }
8640                public List<LiTagOpenContext> liTagOpen() {
8641                        return getRuleContexts(LiTagOpenContext.class);
8642                }
8643                public LiTagOpenContext liTagOpen(int i) {
8644                        return getRuleContext(LiTagOpenContext.class,i);
8645                }
8646                public List<TrTagOpenContext> trTagOpen() {
8647                        return getRuleContexts(TrTagOpenContext.class);
8648                }
8649                public TrTagOpenContext trTagOpen(int i) {
8650                        return getRuleContext(TrTagOpenContext.class,i);
8651                }
8652                public List<TdTagOpenContext> tdTagOpen() {
8653                        return getRuleContexts(TdTagOpenContext.class);
8654                }
8655                public TdTagOpenContext tdTagOpen(int i) {
8656                        return getRuleContext(TdTagOpenContext.class,i);
8657                }
8658                public List<ThTagOpenContext> thTagOpen() {
8659                        return getRuleContexts(ThTagOpenContext.class);
8660                }
8661                public ThTagOpenContext thTagOpen(int i) {
8662                        return getRuleContext(ThTagOpenContext.class,i);
8663                }
8664                public List<BodyTagOpenContext> bodyTagOpen() {
8665                        return getRuleContexts(BodyTagOpenContext.class);
8666                }
8667                public BodyTagOpenContext bodyTagOpen(int i) {
8668                        return getRuleContext(BodyTagOpenContext.class,i);
8669                }
8670                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8671                        return getRuleContexts(ColgroupTagOpenContext.class);
8672                }
8673                public ColgroupTagOpenContext colgroupTagOpen(int i) {
8674                        return getRuleContext(ColgroupTagOpenContext.class,i);
8675                }
8676                public List<DdTagOpenContext> ddTagOpen() {
8677                        return getRuleContexts(DdTagOpenContext.class);
8678                }
8679                public DdTagOpenContext ddTagOpen(int i) {
8680                        return getRuleContext(DdTagOpenContext.class,i);
8681                }
8682                public List<DtTagOpenContext> dtTagOpen() {
8683                        return getRuleContexts(DtTagOpenContext.class);
8684                }
8685                public DtTagOpenContext dtTagOpen(int i) {
8686                        return getRuleContext(DtTagOpenContext.class,i);
8687                }
8688                public List<HeadTagOpenContext> headTagOpen() {
8689                        return getRuleContexts(HeadTagOpenContext.class);
8690                }
8691                public HeadTagOpenContext headTagOpen(int i) {
8692                        return getRuleContext(HeadTagOpenContext.class,i);
8693                }
8694                public List<OptionTagOpenContext> optionTagOpen() {
8695                        return getRuleContexts(OptionTagOpenContext.class);
8696                }
8697                public OptionTagOpenContext optionTagOpen(int i) {
8698                        return getRuleContext(OptionTagOpenContext.class,i);
8699                }
8700                public List<TbodyTagOpenContext> tbodyTagOpen() {
8701                        return getRuleContexts(TbodyTagOpenContext.class);
8702                }
8703                public TbodyTagOpenContext tbodyTagOpen(int i) {
8704                        return getRuleContext(TbodyTagOpenContext.class,i);
8705                }
8706                public List<TheadTagOpenContext> theadTagOpen() {
8707                        return getRuleContexts(TheadTagOpenContext.class);
8708                }
8709                public TheadTagOpenContext theadTagOpen(int i) {
8710                        return getRuleContext(TheadTagOpenContext.class,i);
8711                }
8712                public List<TfootTagOpenContext> tfootTagOpen() {
8713                        return getRuleContexts(TfootTagOpenContext.class);
8714                }
8715                public TfootTagOpenContext tfootTagOpen(int i) {
8716                        return getRuleContext(TfootTagOpenContext.class,i);
8717                }
8718                public List<HtmlCommentContext> htmlComment() {
8719                        return getRuleContexts(HtmlCommentContext.class);
8720                }
8721                public HtmlCommentContext htmlComment(int i) {
8722                        return getRuleContext(HtmlCommentContext.class,i);
8723                }
8724                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8725                public TerminalNode CDATA(int i) {
8726                        return getToken(JavadocParser.CDATA, i);
8727                }
8728                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8729                public TerminalNode NEWLINE(int i) {
8730                        return getToken(JavadocParser.NEWLINE, i);
8731                }
8732                public List<TextContext> text() {
8733                        return getRuleContexts(TextContext.class);
8734                }
8735                public TextContext text(int i) {
8736                        return getRuleContext(TextContext.class,i);
8737                }
8738                public List<JavadocInlineTagContext> javadocInlineTag() {
8739                        return getRuleContexts(JavadocInlineTagContext.class);
8740                }
8741                public JavadocInlineTagContext javadocInlineTag(int i) {
8742                        return getRuleContext(JavadocInlineTagContext.class,i);
8743                }
8744                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8745                public TerminalNode LEADING_ASTERISK(int i) {
8746                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8747                }
8748                public HtmlContext(ParserRuleContext parent, int invokingState) {
8749                        super(parent, invokingState);
8750                }
8751                @Override public int getRuleIndex() { return RULE_html; }
8752                @Override
8753                public void enterRule(ParseTreeListener listener) {
8754                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this);
8755                }
8756                @Override
8757                public void exitRule(ParseTreeListener listener) {
8758                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this);
8759                }
8760                @Override
8761                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8762                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this);
8763                        else return visitor.visitChildren(this);
8764                }
8765        }
8766
8767        public final HtmlContext html() throws RecognitionException {
8768                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8769                enterRule(_localctx, 76, RULE_html);
8770                try {
8771                        int _alt;
8772                        enterOuterAlt(_localctx, 1);
8773                        {
8774                        setState(1020);
8775                        htmlTagOpen();
8776                        setState(1060);
8777                        _errHandler.sync(this);
8778                        _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8779                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8780                                if ( _alt==1 ) {
8781                                        {
8782                                        setState(1058);
8783                                        _errHandler.sync(this);
8784                                        switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
8785                                        case 1:
8786                                                {
8787                                                setState(1021);
8788                                                htmlTag();
8789                                                }
8790                                                break;
8791                                        case 2:
8792                                                {
8793                                                setState(1022);
8794                                                singletonTag();
8795                                                }
8796                                                break;
8797                                        case 3:
8798                                                {
8799                                                setState(1023);
8800                                                paragraph();
8801                                                }
8802                                                break;
8803                                        case 4:
8804                                                {
8805                                                setState(1024);
8806                                                li();
8807                                                }
8808                                                break;
8809                                        case 5:
8810                                                {
8811                                                setState(1025);
8812                                                tr();
8813                                                }
8814                                                break;
8815                                        case 6:
8816                                                {
8817                                                setState(1026);
8818                                                td();
8819                                                }
8820                                                break;
8821                                        case 7:
8822                                                {
8823                                                setState(1027);
8824                                                th();
8825                                                }
8826                                                break;
8827                                        case 8:
8828                                                {
8829                                                setState(1028);
8830                                                body();
8831                                                }
8832                                                break;
8833                                        case 9:
8834                                                {
8835                                                setState(1029);
8836                                                colgroup();
8837                                                }
8838                                                break;
8839                                        case 10:
8840                                                {
8841                                                setState(1030);
8842                                                dd();
8843                                                }
8844                                                break;
8845                                        case 11:
8846                                                {
8847                                                setState(1031);
8848                                                dt();
8849                                                }
8850                                                break;
8851                                        case 12:
8852                                                {
8853                                                setState(1032);
8854                                                head();
8855                                                }
8856                                                break;
8857                                        case 13:
8858                                                {
8859                                                setState(1033);
8860                                                option();
8861                                                }
8862                                                break;
8863                                        case 14:
8864                                                {
8865                                                setState(1034);
8866                                                tbody();
8867                                                }
8868                                                break;
8869                                        case 15:
8870                                                {
8871                                                setState(1035);
8872                                                thead();
8873                                                }
8874                                                break;
8875                                        case 16:
8876                                                {
8877                                                setState(1036);
8878                                                tfoot();
8879                                                }
8880                                                break;
8881                                        case 17:
8882                                                {
8883                                                setState(1037);
8884                                                pTagOpen();
8885                                                }
8886                                                break;
8887                                        case 18:
8888                                                {
8889                                                setState(1038);
8890                                                liTagOpen();
8891                                                }
8892                                                break;
8893                                        case 19:
8894                                                {
8895                                                setState(1039);
8896                                                trTagOpen();
8897                                                }
8898                                                break;
8899                                        case 20:
8900                                                {
8901                                                setState(1040);
8902                                                tdTagOpen();
8903                                                }
8904                                                break;
8905                                        case 21:
8906                                                {
8907                                                setState(1041);
8908                                                thTagOpen();
8909                                                }
8910                                                break;
8911                                        case 22:
8912                                                {
8913                                                setState(1042);
8914                                                bodyTagOpen();
8915                                                }
8916                                                break;
8917                                        case 23:
8918                                                {
8919                                                setState(1043);
8920                                                colgroupTagOpen();
8921                                                }
8922                                                break;
8923                                        case 24:
8924                                                {
8925                                                setState(1044);
8926                                                ddTagOpen();
8927                                                }
8928                                                break;
8929                                        case 25:
8930                                                {
8931                                                setState(1045);
8932                                                dtTagOpen();
8933                                                }
8934                                                break;
8935                                        case 26:
8936                                                {
8937                                                setState(1046);
8938                                                headTagOpen();
8939                                                }
8940                                                break;
8941                                        case 27:
8942                                                {
8943                                                setState(1047);
8944                                                optionTagOpen();
8945                                                }
8946                                                break;
8947                                        case 28:
8948                                                {
8949                                                setState(1048);
8950                                                tbodyTagOpen();
8951                                                }
8952                                                break;
8953                                        case 29:
8954                                                {
8955                                                setState(1049);
8956                                                theadTagOpen();
8957                                                }
8958                                                break;
8959                                        case 30:
8960                                                {
8961                                                setState(1050);
8962                                                tfootTagOpen();
8963                                                }
8964                                                break;
8965                                        case 31:
8966                                                {
8967                                                {
8968                                                setState(1051);
8969                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8970                                                setState(1052);
8971                                                match(LEADING_ASTERISK);
8972                                                }
8973                                                }
8974                                                break;
8975                                        case 32:
8976                                                {
8977                                                setState(1053);
8978                                                htmlComment();
8979                                                }
8980                                                break;
8981                                        case 33:
8982                                                {
8983                                                setState(1054);
8984                                                match(CDATA);
8985                                                }
8986                                                break;
8987                                        case 34:
8988                                                {
8989                                                setState(1055);
8990                                                match(NEWLINE);
8991                                                }
8992                                                break;
8993                                        case 35:
8994                                                {
8995                                                setState(1056);
8996                                                text();
8997                                                }
8998                                                break;
8999                                        case 36:
9000                                                {
9001                                                setState(1057);
9002                                                javadocInlineTag();
9003                                                }
9004                                                break;
9005                                        }
9006                                        } 
9007                                }
9008                                setState(1062);
9009                                _errHandler.sync(this);
9010                                _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
9011                        }
9012                        setState(1063);
9013                        htmlTagClose();
9014                        }
9015                }
9016                catch (RecognitionException re) {
9017                        _localctx.exception = re;
9018                        _errHandler.reportError(this, re);
9019                        _errHandler.recover(this, re);
9020                }
9021                finally {
9022                        exitRule();
9023                }
9024                return _localctx;
9025        }
9026
9027        public static class OptionTagOpenContext extends ParserRuleContext {
9028                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9029                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9030                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9031                public List<AttributeContext> attribute() {
9032                        return getRuleContexts(AttributeContext.class);
9033                }
9034                public AttributeContext attribute(int i) {
9035                        return getRuleContext(AttributeContext.class,i);
9036                }
9037                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9038                public TerminalNode NEWLINE(int i) {
9039                        return getToken(JavadocParser.NEWLINE, i);
9040                }
9041                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9042                public TerminalNode LEADING_ASTERISK(int i) {
9043                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9044                }
9045                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9046                public TerminalNode WS(int i) {
9047                        return getToken(JavadocParser.WS, i);
9048                }
9049                public OptionTagOpenContext(ParserRuleContext parent, int invokingState) {
9050                        super(parent, invokingState);
9051                }
9052                @Override public int getRuleIndex() { return RULE_optionTagOpen; }
9053                @Override
9054                public void enterRule(ParseTreeListener listener) {
9055                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this);
9056                }
9057                @Override
9058                public void exitRule(ParseTreeListener listener) {
9059                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this);
9060                }
9061                @Override
9062                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9063                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this);
9064                        else return visitor.visitChildren(this);
9065                }
9066        }
9067
9068        public final OptionTagOpenContext optionTagOpen() throws RecognitionException {
9069                OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState());
9070                enterRule(_localctx, 78, RULE_optionTagOpen);
9071                int _la;
9072                try {
9073                        enterOuterAlt(_localctx, 1);
9074                        {
9075                        setState(1065);
9076                        match(OPEN);
9077                        setState(1066);
9078                        match(OPTION_HTML_TAG_NAME);
9079                        setState(1073);
9080                        _errHandler.sync(this);
9081                        _la = _input.LA(1);
9082                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9083                                {
9084                                setState(1071);
9085                                _errHandler.sync(this);
9086                                switch (_input.LA(1)) {
9087                                case HTML_TAG_NAME:
9088                                        {
9089                                        setState(1067);
9090                                        attribute();
9091                                        }
9092                                        break;
9093                                case NEWLINE:
9094                                        {
9095                                        setState(1068);
9096                                        match(NEWLINE);
9097                                        }
9098                                        break;
9099                                case LEADING_ASTERISK:
9100                                        {
9101                                        setState(1069);
9102                                        match(LEADING_ASTERISK);
9103                                        }
9104                                        break;
9105                                case WS:
9106                                        {
9107                                        setState(1070);
9108                                        match(WS);
9109                                        }
9110                                        break;
9111                                default:
9112                                        throw new NoViableAltException(this);
9113                                }
9114                                }
9115                                setState(1075);
9116                                _errHandler.sync(this);
9117                                _la = _input.LA(1);
9118                        }
9119                        setState(1076);
9120                        match(CLOSE);
9121                        }
9122                }
9123                catch (RecognitionException re) {
9124                        _localctx.exception = re;
9125                        _errHandler.reportError(this, re);
9126                        _errHandler.recover(this, re);
9127                }
9128                finally {
9129                        exitRule();
9130                }
9131                return _localctx;
9132        }
9133
9134        public static class OptionTagCloseContext extends ParserRuleContext {
9135                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9136                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9137                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9138                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9139                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9140                public TerminalNode NEWLINE(int i) {
9141                        return getToken(JavadocParser.NEWLINE, i);
9142                }
9143                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9144                public TerminalNode LEADING_ASTERISK(int i) {
9145                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9146                }
9147                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9148                public TerminalNode WS(int i) {
9149                        return getToken(JavadocParser.WS, i);
9150                }
9151                public OptionTagCloseContext(ParserRuleContext parent, int invokingState) {
9152                        super(parent, invokingState);
9153                }
9154                @Override public int getRuleIndex() { return RULE_optionTagClose; }
9155                @Override
9156                public void enterRule(ParseTreeListener listener) {
9157                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this);
9158                }
9159                @Override
9160                public void exitRule(ParseTreeListener listener) {
9161                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this);
9162                }
9163                @Override
9164                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9165                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this);
9166                        else return visitor.visitChildren(this);
9167                }
9168        }
9169
9170        public final OptionTagCloseContext optionTagClose() throws RecognitionException {
9171                OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState());
9172                enterRule(_localctx, 80, RULE_optionTagClose);
9173                int _la;
9174                try {
9175                        enterOuterAlt(_localctx, 1);
9176                        {
9177                        setState(1078);
9178                        match(OPEN);
9179                        setState(1079);
9180                        match(SLASH);
9181                        setState(1080);
9182                        match(OPTION_HTML_TAG_NAME);
9183                        setState(1084);
9184                        _errHandler.sync(this);
9185                        _la = _input.LA(1);
9186                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9187                                {
9188                                {
9189                                setState(1081);
9190                                _la = _input.LA(1);
9191                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9192                                _errHandler.recoverInline(this);
9193                                }
9194                                else {
9195                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
9196                                        _errHandler.reportMatch(this);
9197                                        consume();
9198                                }
9199                                }
9200                                }
9201                                setState(1086);
9202                                _errHandler.sync(this);
9203                                _la = _input.LA(1);
9204                        }
9205                        setState(1087);
9206                        match(CLOSE);
9207                        }
9208                }
9209                catch (RecognitionException re) {
9210                        _localctx.exception = re;
9211                        _errHandler.reportError(this, re);
9212                        _errHandler.recover(this, re);
9213                }
9214                finally {
9215                        exitRule();
9216                }
9217                return _localctx;
9218        }
9219
9220        public static class OptionContext extends ParserRuleContext {
9221                public OptionTagOpenContext optionTagOpen() {
9222                        return getRuleContext(OptionTagOpenContext.class,0);
9223                }
9224                public OptionTagCloseContext optionTagClose() {
9225                        return getRuleContext(OptionTagCloseContext.class,0);
9226                }
9227                public List<HtmlTagContext> htmlTag() {
9228                        return getRuleContexts(HtmlTagContext.class);
9229                }
9230                public HtmlTagContext htmlTag(int i) {
9231                        return getRuleContext(HtmlTagContext.class,i);
9232                }
9233                public List<SingletonTagContext> singletonTag() {
9234                        return getRuleContexts(SingletonTagContext.class);
9235                }
9236                public SingletonTagContext singletonTag(int i) {
9237                        return getRuleContext(SingletonTagContext.class,i);
9238                }
9239                public List<ParagraphContext> paragraph() {
9240                        return getRuleContexts(ParagraphContext.class);
9241                }
9242                public ParagraphContext paragraph(int i) {
9243                        return getRuleContext(ParagraphContext.class,i);
9244                }
9245                public List<LiContext> li() {
9246                        return getRuleContexts(LiContext.class);
9247                }
9248                public LiContext li(int i) {
9249                        return getRuleContext(LiContext.class,i);
9250                }
9251                public List<TrContext> tr() {
9252                        return getRuleContexts(TrContext.class);
9253                }
9254                public TrContext tr(int i) {
9255                        return getRuleContext(TrContext.class,i);
9256                }
9257                public List<TdContext> td() {
9258                        return getRuleContexts(TdContext.class);
9259                }
9260                public TdContext td(int i) {
9261                        return getRuleContext(TdContext.class,i);
9262                }
9263                public List<ThContext> th() {
9264                        return getRuleContexts(ThContext.class);
9265                }
9266                public ThContext th(int i) {
9267                        return getRuleContext(ThContext.class,i);
9268                }
9269                public List<BodyContext> body() {
9270                        return getRuleContexts(BodyContext.class);
9271                }
9272                public BodyContext body(int i) {
9273                        return getRuleContext(BodyContext.class,i);
9274                }
9275                public List<ColgroupContext> colgroup() {
9276                        return getRuleContexts(ColgroupContext.class);
9277                }
9278                public ColgroupContext colgroup(int i) {
9279                        return getRuleContext(ColgroupContext.class,i);
9280                }
9281                public List<DdContext> dd() {
9282                        return getRuleContexts(DdContext.class);
9283                }
9284                public DdContext dd(int i) {
9285                        return getRuleContext(DdContext.class,i);
9286                }
9287                public List<DtContext> dt() {
9288                        return getRuleContexts(DtContext.class);
9289                }
9290                public DtContext dt(int i) {
9291                        return getRuleContext(DtContext.class,i);
9292                }
9293                public List<HeadContext> head() {
9294                        return getRuleContexts(HeadContext.class);
9295                }
9296                public HeadContext head(int i) {
9297                        return getRuleContext(HeadContext.class,i);
9298                }
9299                public List<HtmlContext> html() {
9300                        return getRuleContexts(HtmlContext.class);
9301                }
9302                public HtmlContext html(int i) {
9303                        return getRuleContext(HtmlContext.class,i);
9304                }
9305                public List<TbodyContext> tbody() {
9306                        return getRuleContexts(TbodyContext.class);
9307                }
9308                public TbodyContext tbody(int i) {
9309                        return getRuleContext(TbodyContext.class,i);
9310                }
9311                public List<TheadContext> thead() {
9312                        return getRuleContexts(TheadContext.class);
9313                }
9314                public TheadContext thead(int i) {
9315                        return getRuleContext(TheadContext.class,i);
9316                }
9317                public List<TfootContext> tfoot() {
9318                        return getRuleContexts(TfootContext.class);
9319                }
9320                public TfootContext tfoot(int i) {
9321                        return getRuleContext(TfootContext.class,i);
9322                }
9323                public List<PTagOpenContext> pTagOpen() {
9324                        return getRuleContexts(PTagOpenContext.class);
9325                }
9326                public PTagOpenContext pTagOpen(int i) {
9327                        return getRuleContext(PTagOpenContext.class,i);
9328                }
9329                public List<LiTagOpenContext> liTagOpen() {
9330                        return getRuleContexts(LiTagOpenContext.class);
9331                }
9332                public LiTagOpenContext liTagOpen(int i) {
9333                        return getRuleContext(LiTagOpenContext.class,i);
9334                }
9335                public List<TrTagOpenContext> trTagOpen() {
9336                        return getRuleContexts(TrTagOpenContext.class);
9337                }
9338                public TrTagOpenContext trTagOpen(int i) {
9339                        return getRuleContext(TrTagOpenContext.class,i);
9340                }
9341                public List<TdTagOpenContext> tdTagOpen() {
9342                        return getRuleContexts(TdTagOpenContext.class);
9343                }
9344                public TdTagOpenContext tdTagOpen(int i) {
9345                        return getRuleContext(TdTagOpenContext.class,i);
9346                }
9347                public List<ThTagOpenContext> thTagOpen() {
9348                        return getRuleContexts(ThTagOpenContext.class);
9349                }
9350                public ThTagOpenContext thTagOpen(int i) {
9351                        return getRuleContext(ThTagOpenContext.class,i);
9352                }
9353                public List<BodyTagOpenContext> bodyTagOpen() {
9354                        return getRuleContexts(BodyTagOpenContext.class);
9355                }
9356                public BodyTagOpenContext bodyTagOpen(int i) {
9357                        return getRuleContext(BodyTagOpenContext.class,i);
9358                }
9359                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9360                        return getRuleContexts(ColgroupTagOpenContext.class);
9361                }
9362                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9363                        return getRuleContext(ColgroupTagOpenContext.class,i);
9364                }
9365                public List<DdTagOpenContext> ddTagOpen() {
9366                        return getRuleContexts(DdTagOpenContext.class);
9367                }
9368                public DdTagOpenContext ddTagOpen(int i) {
9369                        return getRuleContext(DdTagOpenContext.class,i);
9370                }
9371                public List<DtTagOpenContext> dtTagOpen() {
9372                        return getRuleContexts(DtTagOpenContext.class);
9373                }
9374                public DtTagOpenContext dtTagOpen(int i) {
9375                        return getRuleContext(DtTagOpenContext.class,i);
9376                }
9377                public List<HeadTagOpenContext> headTagOpen() {
9378                        return getRuleContexts(HeadTagOpenContext.class);
9379                }
9380                public HeadTagOpenContext headTagOpen(int i) {
9381                        return getRuleContext(HeadTagOpenContext.class,i);
9382                }
9383                public List<HtmlTagOpenContext> htmlTagOpen() {
9384                        return getRuleContexts(HtmlTagOpenContext.class);
9385                }
9386                public HtmlTagOpenContext htmlTagOpen(int i) {
9387                        return getRuleContext(HtmlTagOpenContext.class,i);
9388                }
9389                public List<TbodyTagOpenContext> tbodyTagOpen() {
9390                        return getRuleContexts(TbodyTagOpenContext.class);
9391                }
9392                public TbodyTagOpenContext tbodyTagOpen(int i) {
9393                        return getRuleContext(TbodyTagOpenContext.class,i);
9394                }
9395                public List<TheadTagOpenContext> theadTagOpen() {
9396                        return getRuleContexts(TheadTagOpenContext.class);
9397                }
9398                public TheadTagOpenContext theadTagOpen(int i) {
9399                        return getRuleContext(TheadTagOpenContext.class,i);
9400                }
9401                public List<TfootTagOpenContext> tfootTagOpen() {
9402                        return getRuleContexts(TfootTagOpenContext.class);
9403                }
9404                public TfootTagOpenContext tfootTagOpen(int i) {
9405                        return getRuleContext(TfootTagOpenContext.class,i);
9406                }
9407                public List<HtmlCommentContext> htmlComment() {
9408                        return getRuleContexts(HtmlCommentContext.class);
9409                }
9410                public HtmlCommentContext htmlComment(int i) {
9411                        return getRuleContext(HtmlCommentContext.class,i);
9412                }
9413                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9414                public TerminalNode CDATA(int i) {
9415                        return getToken(JavadocParser.CDATA, i);
9416                }
9417                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9418                public TerminalNode NEWLINE(int i) {
9419                        return getToken(JavadocParser.NEWLINE, i);
9420                }
9421                public List<TextContext> text() {
9422                        return getRuleContexts(TextContext.class);
9423                }
9424                public TextContext text(int i) {
9425                        return getRuleContext(TextContext.class,i);
9426                }
9427                public List<JavadocInlineTagContext> javadocInlineTag() {
9428                        return getRuleContexts(JavadocInlineTagContext.class);
9429                }
9430                public JavadocInlineTagContext javadocInlineTag(int i) {
9431                        return getRuleContext(JavadocInlineTagContext.class,i);
9432                }
9433                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9434                public TerminalNode LEADING_ASTERISK(int i) {
9435                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9436                }
9437                public OptionContext(ParserRuleContext parent, int invokingState) {
9438                        super(parent, invokingState);
9439                }
9440                @Override public int getRuleIndex() { return RULE_option; }
9441                @Override
9442                public void enterRule(ParseTreeListener listener) {
9443                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this);
9444                }
9445                @Override
9446                public void exitRule(ParseTreeListener listener) {
9447                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this);
9448                }
9449                @Override
9450                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9451                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this);
9452                        else return visitor.visitChildren(this);
9453                }
9454        }
9455
9456        public final OptionContext option() throws RecognitionException {
9457                OptionContext _localctx = new OptionContext(_ctx, getState());
9458                enterRule(_localctx, 82, RULE_option);
9459                try {
9460                        int _alt;
9461                        enterOuterAlt(_localctx, 1);
9462                        {
9463                        setState(1089);
9464                        optionTagOpen();
9465                        setState(1129);
9466                        _errHandler.sync(this);
9467                        _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9468                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9469                                if ( _alt==1 ) {
9470                                        {
9471                                        setState(1127);
9472                                        _errHandler.sync(this);
9473                                        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
9474                                        case 1:
9475                                                {
9476                                                setState(1090);
9477                                                htmlTag();
9478                                                }
9479                                                break;
9480                                        case 2:
9481                                                {
9482                                                setState(1091);
9483                                                singletonTag();
9484                                                }
9485                                                break;
9486                                        case 3:
9487                                                {
9488                                                setState(1092);
9489                                                paragraph();
9490                                                }
9491                                                break;
9492                                        case 4:
9493                                                {
9494                                                setState(1093);
9495                                                li();
9496                                                }
9497                                                break;
9498                                        case 5:
9499                                                {
9500                                                setState(1094);
9501                                                tr();
9502                                                }
9503                                                break;
9504                                        case 6:
9505                                                {
9506                                                setState(1095);
9507                                                td();
9508                                                }
9509                                                break;
9510                                        case 7:
9511                                                {
9512                                                setState(1096);
9513                                                th();
9514                                                }
9515                                                break;
9516                                        case 8:
9517                                                {
9518                                                setState(1097);
9519                                                body();
9520                                                }
9521                                                break;
9522                                        case 9:
9523                                                {
9524                                                setState(1098);
9525                                                colgroup();
9526                                                }
9527                                                break;
9528                                        case 10:
9529                                                {
9530                                                setState(1099);
9531                                                dd();
9532                                                }
9533                                                break;
9534                                        case 11:
9535                                                {
9536                                                setState(1100);
9537                                                dt();
9538                                                }
9539                                                break;
9540                                        case 12:
9541                                                {
9542                                                setState(1101);
9543                                                head();
9544                                                }
9545                                                break;
9546                                        case 13:
9547                                                {
9548                                                setState(1102);
9549                                                html();
9550                                                }
9551                                                break;
9552                                        case 14:
9553                                                {
9554                                                setState(1103);
9555                                                tbody();
9556                                                }
9557                                                break;
9558                                        case 15:
9559                                                {
9560                                                setState(1104);
9561                                                thead();
9562                                                }
9563                                                break;
9564                                        case 16:
9565                                                {
9566                                                setState(1105);
9567                                                tfoot();
9568                                                }
9569                                                break;
9570                                        case 17:
9571                                                {
9572                                                setState(1106);
9573                                                pTagOpen();
9574                                                }
9575                                                break;
9576                                        case 18:
9577                                                {
9578                                                setState(1107);
9579                                                liTagOpen();
9580                                                }
9581                                                break;
9582                                        case 19:
9583                                                {
9584                                                setState(1108);
9585                                                trTagOpen();
9586                                                }
9587                                                break;
9588                                        case 20:
9589                                                {
9590                                                setState(1109);
9591                                                tdTagOpen();
9592                                                }
9593                                                break;
9594                                        case 21:
9595                                                {
9596                                                setState(1110);
9597                                                thTagOpen();
9598                                                }
9599                                                break;
9600                                        case 22:
9601                                                {
9602                                                setState(1111);
9603                                                bodyTagOpen();
9604                                                }
9605                                                break;
9606                                        case 23:
9607                                                {
9608                                                setState(1112);
9609                                                colgroupTagOpen();
9610                                                }
9611                                                break;
9612                                        case 24:
9613                                                {
9614                                                setState(1113);
9615                                                ddTagOpen();
9616                                                }
9617                                                break;
9618                                        case 25:
9619                                                {
9620                                                setState(1114);
9621                                                dtTagOpen();
9622                                                }
9623                                                break;
9624                                        case 26:
9625                                                {
9626                                                setState(1115);
9627                                                headTagOpen();
9628                                                }
9629                                                break;
9630                                        case 27:
9631                                                {
9632                                                setState(1116);
9633                                                htmlTagOpen();
9634                                                }
9635                                                break;
9636                                        case 28:
9637                                                {
9638                                                setState(1117);
9639                                                tbodyTagOpen();
9640                                                }
9641                                                break;
9642                                        case 29:
9643                                                {
9644                                                setState(1118);
9645                                                theadTagOpen();
9646                                                }
9647                                                break;
9648                                        case 30:
9649                                                {
9650                                                setState(1119);
9651                                                tfootTagOpen();
9652                                                }
9653                                                break;
9654                                        case 31:
9655                                                {
9656                                                {
9657                                                setState(1120);
9658                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9659                                                setState(1121);
9660                                                match(LEADING_ASTERISK);
9661                                                }
9662                                                }
9663                                                break;
9664                                        case 32:
9665                                                {
9666                                                setState(1122);
9667                                                htmlComment();
9668                                                }
9669                                                break;
9670                                        case 33:
9671                                                {
9672                                                setState(1123);
9673                                                match(CDATA);
9674                                                }
9675                                                break;
9676                                        case 34:
9677                                                {
9678                                                setState(1124);
9679                                                match(NEWLINE);
9680                                                }
9681                                                break;
9682                                        case 35:
9683                                                {
9684                                                setState(1125);
9685                                                text();
9686                                                }
9687                                                break;
9688                                        case 36:
9689                                                {
9690                                                setState(1126);
9691                                                javadocInlineTag();
9692                                                }
9693                                                break;
9694                                        }
9695                                        } 
9696                                }
9697                                setState(1131);
9698                                _errHandler.sync(this);
9699                                _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9700                        }
9701                        setState(1132);
9702                        optionTagClose();
9703                        }
9704                }
9705                catch (RecognitionException re) {
9706                        _localctx.exception = re;
9707                        _errHandler.reportError(this, re);
9708                        _errHandler.recover(this, re);
9709                }
9710                finally {
9711                        exitRule();
9712                }
9713                return _localctx;
9714        }
9715
9716        public static class TbodyTagOpenContext extends ParserRuleContext {
9717                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9718                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9719                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9720                public List<AttributeContext> attribute() {
9721                        return getRuleContexts(AttributeContext.class);
9722                }
9723                public AttributeContext attribute(int i) {
9724                        return getRuleContext(AttributeContext.class,i);
9725                }
9726                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9727                public TerminalNode NEWLINE(int i) {
9728                        return getToken(JavadocParser.NEWLINE, i);
9729                }
9730                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9731                public TerminalNode LEADING_ASTERISK(int i) {
9732                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9733                }
9734                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9735                public TerminalNode WS(int i) {
9736                        return getToken(JavadocParser.WS, i);
9737                }
9738                public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) {
9739                        super(parent, invokingState);
9740                }
9741                @Override public int getRuleIndex() { return RULE_tbodyTagOpen; }
9742                @Override
9743                public void enterRule(ParseTreeListener listener) {
9744                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this);
9745                }
9746                @Override
9747                public void exitRule(ParseTreeListener listener) {
9748                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this);
9749                }
9750                @Override
9751                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9752                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this);
9753                        else return visitor.visitChildren(this);
9754                }
9755        }
9756
9757        public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException {
9758                TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState());
9759                enterRule(_localctx, 84, RULE_tbodyTagOpen);
9760                int _la;
9761                try {
9762                        enterOuterAlt(_localctx, 1);
9763                        {
9764                        setState(1134);
9765                        match(OPEN);
9766                        setState(1135);
9767                        match(TBODY_HTML_TAG_NAME);
9768                        setState(1142);
9769                        _errHandler.sync(this);
9770                        _la = _input.LA(1);
9771                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9772                                {
9773                                setState(1140);
9774                                _errHandler.sync(this);
9775                                switch (_input.LA(1)) {
9776                                case HTML_TAG_NAME:
9777                                        {
9778                                        setState(1136);
9779                                        attribute();
9780                                        }
9781                                        break;
9782                                case NEWLINE:
9783                                        {
9784                                        setState(1137);
9785                                        match(NEWLINE);
9786                                        }
9787                                        break;
9788                                case LEADING_ASTERISK:
9789                                        {
9790                                        setState(1138);
9791                                        match(LEADING_ASTERISK);
9792                                        }
9793                                        break;
9794                                case WS:
9795                                        {
9796                                        setState(1139);
9797                                        match(WS);
9798                                        }
9799                                        break;
9800                                default:
9801                                        throw new NoViableAltException(this);
9802                                }
9803                                }
9804                                setState(1144);
9805                                _errHandler.sync(this);
9806                                _la = _input.LA(1);
9807                        }
9808                        setState(1145);
9809                        match(CLOSE);
9810                        }
9811                }
9812                catch (RecognitionException re) {
9813                        _localctx.exception = re;
9814                        _errHandler.reportError(this, re);
9815                        _errHandler.recover(this, re);
9816                }
9817                finally {
9818                        exitRule();
9819                }
9820                return _localctx;
9821        }
9822
9823        public static class TbodyTagCloseContext extends ParserRuleContext {
9824                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9825                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9826                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9827                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9828                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9829                public TerminalNode NEWLINE(int i) {
9830                        return getToken(JavadocParser.NEWLINE, i);
9831                }
9832                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9833                public TerminalNode LEADING_ASTERISK(int i) {
9834                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9835                }
9836                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9837                public TerminalNode WS(int i) {
9838                        return getToken(JavadocParser.WS, i);
9839                }
9840                public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) {
9841                        super(parent, invokingState);
9842                }
9843                @Override public int getRuleIndex() { return RULE_tbodyTagClose; }
9844                @Override
9845                public void enterRule(ParseTreeListener listener) {
9846                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this);
9847                }
9848                @Override
9849                public void exitRule(ParseTreeListener listener) {
9850                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this);
9851                }
9852                @Override
9853                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9854                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this);
9855                        else return visitor.visitChildren(this);
9856                }
9857        }
9858
9859        public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException {
9860                TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState());
9861                enterRule(_localctx, 86, RULE_tbodyTagClose);
9862                int _la;
9863                try {
9864                        enterOuterAlt(_localctx, 1);
9865                        {
9866                        setState(1147);
9867                        match(OPEN);
9868                        setState(1148);
9869                        match(SLASH);
9870                        setState(1149);
9871                        match(TBODY_HTML_TAG_NAME);
9872                        setState(1153);
9873                        _errHandler.sync(this);
9874                        _la = _input.LA(1);
9875                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9876                                {
9877                                {
9878                                setState(1150);
9879                                _la = _input.LA(1);
9880                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9881                                _errHandler.recoverInline(this);
9882                                }
9883                                else {
9884                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
9885                                        _errHandler.reportMatch(this);
9886                                        consume();
9887                                }
9888                                }
9889                                }
9890                                setState(1155);
9891                                _errHandler.sync(this);
9892                                _la = _input.LA(1);
9893                        }
9894                        setState(1156);
9895                        match(CLOSE);
9896                        }
9897                }
9898                catch (RecognitionException re) {
9899                        _localctx.exception = re;
9900                        _errHandler.reportError(this, re);
9901                        _errHandler.recover(this, re);
9902                }
9903                finally {
9904                        exitRule();
9905                }
9906                return _localctx;
9907        }
9908
9909        public static class TbodyContext extends ParserRuleContext {
9910                public TbodyTagOpenContext tbodyTagOpen() {
9911                        return getRuleContext(TbodyTagOpenContext.class,0);
9912                }
9913                public TbodyTagCloseContext tbodyTagClose() {
9914                        return getRuleContext(TbodyTagCloseContext.class,0);
9915                }
9916                public List<HtmlTagContext> htmlTag() {
9917                        return getRuleContexts(HtmlTagContext.class);
9918                }
9919                public HtmlTagContext htmlTag(int i) {
9920                        return getRuleContext(HtmlTagContext.class,i);
9921                }
9922                public List<SingletonTagContext> singletonTag() {
9923                        return getRuleContexts(SingletonTagContext.class);
9924                }
9925                public SingletonTagContext singletonTag(int i) {
9926                        return getRuleContext(SingletonTagContext.class,i);
9927                }
9928                public List<ParagraphContext> paragraph() {
9929                        return getRuleContexts(ParagraphContext.class);
9930                }
9931                public ParagraphContext paragraph(int i) {
9932                        return getRuleContext(ParagraphContext.class,i);
9933                }
9934                public List<LiContext> li() {
9935                        return getRuleContexts(LiContext.class);
9936                }
9937                public LiContext li(int i) {
9938                        return getRuleContext(LiContext.class,i);
9939                }
9940                public List<TrContext> tr() {
9941                        return getRuleContexts(TrContext.class);
9942                }
9943                public TrContext tr(int i) {
9944                        return getRuleContext(TrContext.class,i);
9945                }
9946                public List<TdContext> td() {
9947                        return getRuleContexts(TdContext.class);
9948                }
9949                public TdContext td(int i) {
9950                        return getRuleContext(TdContext.class,i);
9951                }
9952                public List<ThContext> th() {
9953                        return getRuleContexts(ThContext.class);
9954                }
9955                public ThContext th(int i) {
9956                        return getRuleContext(ThContext.class,i);
9957                }
9958                public List<BodyContext> body() {
9959                        return getRuleContexts(BodyContext.class);
9960                }
9961                public BodyContext body(int i) {
9962                        return getRuleContext(BodyContext.class,i);
9963                }
9964                public List<ColgroupContext> colgroup() {
9965                        return getRuleContexts(ColgroupContext.class);
9966                }
9967                public ColgroupContext colgroup(int i) {
9968                        return getRuleContext(ColgroupContext.class,i);
9969                }
9970                public List<DdContext> dd() {
9971                        return getRuleContexts(DdContext.class);
9972                }
9973                public DdContext dd(int i) {
9974                        return getRuleContext(DdContext.class,i);
9975                }
9976                public List<DtContext> dt() {
9977                        return getRuleContexts(DtContext.class);
9978                }
9979                public DtContext dt(int i) {
9980                        return getRuleContext(DtContext.class,i);
9981                }
9982                public List<HeadContext> head() {
9983                        return getRuleContexts(HeadContext.class);
9984                }
9985                public HeadContext head(int i) {
9986                        return getRuleContext(HeadContext.class,i);
9987                }
9988                public List<HtmlContext> html() {
9989                        return getRuleContexts(HtmlContext.class);
9990                }
9991                public HtmlContext html(int i) {
9992                        return getRuleContext(HtmlContext.class,i);
9993                }
9994                public List<OptionContext> option() {
9995                        return getRuleContexts(OptionContext.class);
9996                }
9997                public OptionContext option(int i) {
9998                        return getRuleContext(OptionContext.class,i);
9999                }
10000                public List<TheadContext> thead() {
10001                        return getRuleContexts(TheadContext.class);
10002                }
10003                public TheadContext thead(int i) {
10004                        return getRuleContext(TheadContext.class,i);
10005                }
10006                public List<TfootContext> tfoot() {
10007                        return getRuleContexts(TfootContext.class);
10008                }
10009                public TfootContext tfoot(int i) {
10010                        return getRuleContext(TfootContext.class,i);
10011                }
10012                public List<PTagOpenContext> pTagOpen() {
10013                        return getRuleContexts(PTagOpenContext.class);
10014                }
10015                public PTagOpenContext pTagOpen(int i) {
10016                        return getRuleContext(PTagOpenContext.class,i);
10017                }
10018                public List<LiTagOpenContext> liTagOpen() {
10019                        return getRuleContexts(LiTagOpenContext.class);
10020                }
10021                public LiTagOpenContext liTagOpen(int i) {
10022                        return getRuleContext(LiTagOpenContext.class,i);
10023                }
10024                public List<TrTagOpenContext> trTagOpen() {
10025                        return getRuleContexts(TrTagOpenContext.class);
10026                }
10027                public TrTagOpenContext trTagOpen(int i) {
10028                        return getRuleContext(TrTagOpenContext.class,i);
10029                }
10030                public List<TdTagOpenContext> tdTagOpen() {
10031                        return getRuleContexts(TdTagOpenContext.class);
10032                }
10033                public TdTagOpenContext tdTagOpen(int i) {
10034                        return getRuleContext(TdTagOpenContext.class,i);
10035                }
10036                public List<ThTagOpenContext> thTagOpen() {
10037                        return getRuleContexts(ThTagOpenContext.class);
10038                }
10039                public ThTagOpenContext thTagOpen(int i) {
10040                        return getRuleContext(ThTagOpenContext.class,i);
10041                }
10042                public List<BodyTagOpenContext> bodyTagOpen() {
10043                        return getRuleContexts(BodyTagOpenContext.class);
10044                }
10045                public BodyTagOpenContext bodyTagOpen(int i) {
10046                        return getRuleContext(BodyTagOpenContext.class,i);
10047                }
10048                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10049                        return getRuleContexts(ColgroupTagOpenContext.class);
10050                }
10051                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10052                        return getRuleContext(ColgroupTagOpenContext.class,i);
10053                }
10054                public List<DdTagOpenContext> ddTagOpen() {
10055                        return getRuleContexts(DdTagOpenContext.class);
10056                }
10057                public DdTagOpenContext ddTagOpen(int i) {
10058                        return getRuleContext(DdTagOpenContext.class,i);
10059                }
10060                public List<DtTagOpenContext> dtTagOpen() {
10061                        return getRuleContexts(DtTagOpenContext.class);
10062                }
10063                public DtTagOpenContext dtTagOpen(int i) {
10064                        return getRuleContext(DtTagOpenContext.class,i);
10065                }
10066                public List<HeadTagOpenContext> headTagOpen() {
10067                        return getRuleContexts(HeadTagOpenContext.class);
10068                }
10069                public HeadTagOpenContext headTagOpen(int i) {
10070                        return getRuleContext(HeadTagOpenContext.class,i);
10071                }
10072                public List<HtmlTagOpenContext> htmlTagOpen() {
10073                        return getRuleContexts(HtmlTagOpenContext.class);
10074                }
10075                public HtmlTagOpenContext htmlTagOpen(int i) {
10076                        return getRuleContext(HtmlTagOpenContext.class,i);
10077                }
10078                public List<OptionTagOpenContext> optionTagOpen() {
10079                        return getRuleContexts(OptionTagOpenContext.class);
10080                }
10081                public OptionTagOpenContext optionTagOpen(int i) {
10082                        return getRuleContext(OptionTagOpenContext.class,i);
10083                }
10084                public List<TheadTagOpenContext> theadTagOpen() {
10085                        return getRuleContexts(TheadTagOpenContext.class);
10086                }
10087                public TheadTagOpenContext theadTagOpen(int i) {
10088                        return getRuleContext(TheadTagOpenContext.class,i);
10089                }
10090                public List<TfootTagOpenContext> tfootTagOpen() {
10091                        return getRuleContexts(TfootTagOpenContext.class);
10092                }
10093                public TfootTagOpenContext tfootTagOpen(int i) {
10094                        return getRuleContext(TfootTagOpenContext.class,i);
10095                }
10096                public List<HtmlCommentContext> htmlComment() {
10097                        return getRuleContexts(HtmlCommentContext.class);
10098                }
10099                public HtmlCommentContext htmlComment(int i) {
10100                        return getRuleContext(HtmlCommentContext.class,i);
10101                }
10102                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10103                public TerminalNode CDATA(int i) {
10104                        return getToken(JavadocParser.CDATA, i);
10105                }
10106                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10107                public TerminalNode NEWLINE(int i) {
10108                        return getToken(JavadocParser.NEWLINE, i);
10109                }
10110                public List<TextContext> text() {
10111                        return getRuleContexts(TextContext.class);
10112                }
10113                public TextContext text(int i) {
10114                        return getRuleContext(TextContext.class,i);
10115                }
10116                public List<JavadocInlineTagContext> javadocInlineTag() {
10117                        return getRuleContexts(JavadocInlineTagContext.class);
10118                }
10119                public JavadocInlineTagContext javadocInlineTag(int i) {
10120                        return getRuleContext(JavadocInlineTagContext.class,i);
10121                }
10122                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10123                public TerminalNode LEADING_ASTERISK(int i) {
10124                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10125                }
10126                public TbodyContext(ParserRuleContext parent, int invokingState) {
10127                        super(parent, invokingState);
10128                }
10129                @Override public int getRuleIndex() { return RULE_tbody; }
10130                @Override
10131                public void enterRule(ParseTreeListener listener) {
10132                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this);
10133                }
10134                @Override
10135                public void exitRule(ParseTreeListener listener) {
10136                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this);
10137                }
10138                @Override
10139                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10140                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this);
10141                        else return visitor.visitChildren(this);
10142                }
10143        }
10144
10145        public final TbodyContext tbody() throws RecognitionException {
10146                TbodyContext _localctx = new TbodyContext(_ctx, getState());
10147                enterRule(_localctx, 88, RULE_tbody);
10148                try {
10149                        int _alt;
10150                        enterOuterAlt(_localctx, 1);
10151                        {
10152                        setState(1158);
10153                        tbodyTagOpen();
10154                        setState(1198);
10155                        _errHandler.sync(this);
10156                        _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10157                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10158                                if ( _alt==1 ) {
10159                                        {
10160                                        setState(1196);
10161                                        _errHandler.sync(this);
10162                                        switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
10163                                        case 1:
10164                                                {
10165                                                setState(1159);
10166                                                htmlTag();
10167                                                }
10168                                                break;
10169                                        case 2:
10170                                                {
10171                                                setState(1160);
10172                                                singletonTag();
10173                                                }
10174                                                break;
10175                                        case 3:
10176                                                {
10177                                                setState(1161);
10178                                                paragraph();
10179                                                }
10180                                                break;
10181                                        case 4:
10182                                                {
10183                                                setState(1162);
10184                                                li();
10185                                                }
10186                                                break;
10187                                        case 5:
10188                                                {
10189                                                setState(1163);
10190                                                tr();
10191                                                }
10192                                                break;
10193                                        case 6:
10194                                                {
10195                                                setState(1164);
10196                                                td();
10197                                                }
10198                                                break;
10199                                        case 7:
10200                                                {
10201                                                setState(1165);
10202                                                th();
10203                                                }
10204                                                break;
10205                                        case 8:
10206                                                {
10207                                                setState(1166);
10208                                                body();
10209                                                }
10210                                                break;
10211                                        case 9:
10212                                                {
10213                                                setState(1167);
10214                                                colgroup();
10215                                                }
10216                                                break;
10217                                        case 10:
10218                                                {
10219                                                setState(1168);
10220                                                dd();
10221                                                }
10222                                                break;
10223                                        case 11:
10224                                                {
10225                                                setState(1169);
10226                                                dt();
10227                                                }
10228                                                break;
10229                                        case 12:
10230                                                {
10231                                                setState(1170);
10232                                                head();
10233                                                }
10234                                                break;
10235                                        case 13:
10236                                                {
10237                                                setState(1171);
10238                                                html();
10239                                                }
10240                                                break;
10241                                        case 14:
10242                                                {
10243                                                setState(1172);
10244                                                option();
10245                                                }
10246                                                break;
10247                                        case 15:
10248                                                {
10249                                                setState(1173);
10250                                                thead();
10251                                                }
10252                                                break;
10253                                        case 16:
10254                                                {
10255                                                setState(1174);
10256                                                tfoot();
10257                                                }
10258                                                break;
10259                                        case 17:
10260                                                {
10261                                                setState(1175);
10262                                                pTagOpen();
10263                                                }
10264                                                break;
10265                                        case 18:
10266                                                {
10267                                                setState(1176);
10268                                                liTagOpen();
10269                                                }
10270                                                break;
10271                                        case 19:
10272                                                {
10273                                                setState(1177);
10274                                                trTagOpen();
10275                                                }
10276                                                break;
10277                                        case 20:
10278                                                {
10279                                                setState(1178);
10280                                                tdTagOpen();
10281                                                }
10282                                                break;
10283                                        case 21:
10284                                                {
10285                                                setState(1179);
10286                                                thTagOpen();
10287                                                }
10288                                                break;
10289                                        case 22:
10290                                                {
10291                                                setState(1180);
10292                                                bodyTagOpen();
10293                                                }
10294                                                break;
10295                                        case 23:
10296                                                {
10297                                                setState(1181);
10298                                                colgroupTagOpen();
10299                                                }
10300                                                break;
10301                                        case 24:
10302                                                {
10303                                                setState(1182);
10304                                                ddTagOpen();
10305                                                }
10306                                                break;
10307                                        case 25:
10308                                                {
10309                                                setState(1183);
10310                                                dtTagOpen();
10311                                                }
10312                                                break;
10313                                        case 26:
10314                                                {
10315                                                setState(1184);
10316                                                headTagOpen();
10317                                                }
10318                                                break;
10319                                        case 27:
10320                                                {
10321                                                setState(1185);
10322                                                htmlTagOpen();
10323                                                }
10324                                                break;
10325                                        case 28:
10326                                                {
10327                                                setState(1186);
10328                                                optionTagOpen();
10329                                                }
10330                                                break;
10331                                        case 29:
10332                                                {
10333                                                setState(1187);
10334                                                theadTagOpen();
10335                                                }
10336                                                break;
10337                                        case 30:
10338                                                {
10339                                                setState(1188);
10340                                                tfootTagOpen();
10341                                                }
10342                                                break;
10343                                        case 31:
10344                                                {
10345                                                {
10346                                                setState(1189);
10347                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10348                                                setState(1190);
10349                                                match(LEADING_ASTERISK);
10350                                                }
10351                                                }
10352                                                break;
10353                                        case 32:
10354                                                {
10355                                                setState(1191);
10356                                                htmlComment();
10357                                                }
10358                                                break;
10359                                        case 33:
10360                                                {
10361                                                setState(1192);
10362                                                match(CDATA);
10363                                                }
10364                                                break;
10365                                        case 34:
10366                                                {
10367                                                setState(1193);
10368                                                match(NEWLINE);
10369                                                }
10370                                                break;
10371                                        case 35:
10372                                                {
10373                                                setState(1194);
10374                                                text();
10375                                                }
10376                                                break;
10377                                        case 36:
10378                                                {
10379                                                setState(1195);
10380                                                javadocInlineTag();
10381                                                }
10382                                                break;
10383                                        }
10384                                        } 
10385                                }
10386                                setState(1200);
10387                                _errHandler.sync(this);
10388                                _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10389                        }
10390                        setState(1201);
10391                        tbodyTagClose();
10392                        }
10393                }
10394                catch (RecognitionException re) {
10395                        _localctx.exception = re;
10396                        _errHandler.reportError(this, re);
10397                        _errHandler.recover(this, re);
10398                }
10399                finally {
10400                        exitRule();
10401                }
10402                return _localctx;
10403        }
10404
10405        public static class TfootTagOpenContext extends ParserRuleContext {
10406                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10407                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10408                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10409                public List<AttributeContext> attribute() {
10410                        return getRuleContexts(AttributeContext.class);
10411                }
10412                public AttributeContext attribute(int i) {
10413                        return getRuleContext(AttributeContext.class,i);
10414                }
10415                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10416                public TerminalNode NEWLINE(int i) {
10417                        return getToken(JavadocParser.NEWLINE, i);
10418                }
10419                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10420                public TerminalNode LEADING_ASTERISK(int i) {
10421                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10422                }
10423                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10424                public TerminalNode WS(int i) {
10425                        return getToken(JavadocParser.WS, i);
10426                }
10427                public TfootTagOpenContext(ParserRuleContext parent, int invokingState) {
10428                        super(parent, invokingState);
10429                }
10430                @Override public int getRuleIndex() { return RULE_tfootTagOpen; }
10431                @Override
10432                public void enterRule(ParseTreeListener listener) {
10433                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this);
10434                }
10435                @Override
10436                public void exitRule(ParseTreeListener listener) {
10437                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this);
10438                }
10439                @Override
10440                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10441                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this);
10442                        else return visitor.visitChildren(this);
10443                }
10444        }
10445
10446        public final TfootTagOpenContext tfootTagOpen() throws RecognitionException {
10447                TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState());
10448                enterRule(_localctx, 90, RULE_tfootTagOpen);
10449                int _la;
10450                try {
10451                        enterOuterAlt(_localctx, 1);
10452                        {
10453                        setState(1203);
10454                        match(OPEN);
10455                        setState(1204);
10456                        match(TFOOT_HTML_TAG_NAME);
10457                        setState(1211);
10458                        _errHandler.sync(this);
10459                        _la = _input.LA(1);
10460                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10461                                {
10462                                setState(1209);
10463                                _errHandler.sync(this);
10464                                switch (_input.LA(1)) {
10465                                case HTML_TAG_NAME:
10466                                        {
10467                                        setState(1205);
10468                                        attribute();
10469                                        }
10470                                        break;
10471                                case NEWLINE:
10472                                        {
10473                                        setState(1206);
10474                                        match(NEWLINE);
10475                                        }
10476                                        break;
10477                                case LEADING_ASTERISK:
10478                                        {
10479                                        setState(1207);
10480                                        match(LEADING_ASTERISK);
10481                                        }
10482                                        break;
10483                                case WS:
10484                                        {
10485                                        setState(1208);
10486                                        match(WS);
10487                                        }
10488                                        break;
10489                                default:
10490                                        throw new NoViableAltException(this);
10491                                }
10492                                }
10493                                setState(1213);
10494                                _errHandler.sync(this);
10495                                _la = _input.LA(1);
10496                        }
10497                        setState(1214);
10498                        match(CLOSE);
10499                        }
10500                }
10501                catch (RecognitionException re) {
10502                        _localctx.exception = re;
10503                        _errHandler.reportError(this, re);
10504                        _errHandler.recover(this, re);
10505                }
10506                finally {
10507                        exitRule();
10508                }
10509                return _localctx;
10510        }
10511
10512        public static class TfootTagCloseContext extends ParserRuleContext {
10513                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10514                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10515                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10516                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10517                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10518                public TerminalNode NEWLINE(int i) {
10519                        return getToken(JavadocParser.NEWLINE, i);
10520                }
10521                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10522                public TerminalNode LEADING_ASTERISK(int i) {
10523                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10524                }
10525                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10526                public TerminalNode WS(int i) {
10527                        return getToken(JavadocParser.WS, i);
10528                }
10529                public TfootTagCloseContext(ParserRuleContext parent, int invokingState) {
10530                        super(parent, invokingState);
10531                }
10532                @Override public int getRuleIndex() { return RULE_tfootTagClose; }
10533                @Override
10534                public void enterRule(ParseTreeListener listener) {
10535                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this);
10536                }
10537                @Override
10538                public void exitRule(ParseTreeListener listener) {
10539                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this);
10540                }
10541                @Override
10542                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10543                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this);
10544                        else return visitor.visitChildren(this);
10545                }
10546        }
10547
10548        public final TfootTagCloseContext tfootTagClose() throws RecognitionException {
10549                TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState());
10550                enterRule(_localctx, 92, RULE_tfootTagClose);
10551                int _la;
10552                try {
10553                        enterOuterAlt(_localctx, 1);
10554                        {
10555                        setState(1216);
10556                        match(OPEN);
10557                        setState(1217);
10558                        match(SLASH);
10559                        setState(1218);
10560                        match(TFOOT_HTML_TAG_NAME);
10561                        setState(1222);
10562                        _errHandler.sync(this);
10563                        _la = _input.LA(1);
10564                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10565                                {
10566                                {
10567                                setState(1219);
10568                                _la = _input.LA(1);
10569                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10570                                _errHandler.recoverInline(this);
10571                                }
10572                                else {
10573                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
10574                                        _errHandler.reportMatch(this);
10575                                        consume();
10576                                }
10577                                }
10578                                }
10579                                setState(1224);
10580                                _errHandler.sync(this);
10581                                _la = _input.LA(1);
10582                        }
10583                        setState(1225);
10584                        match(CLOSE);
10585                        }
10586                }
10587                catch (RecognitionException re) {
10588                        _localctx.exception = re;
10589                        _errHandler.reportError(this, re);
10590                        _errHandler.recover(this, re);
10591                }
10592                finally {
10593                        exitRule();
10594                }
10595                return _localctx;
10596        }
10597
10598        public static class TfootContext extends ParserRuleContext {
10599                public TfootTagOpenContext tfootTagOpen() {
10600                        return getRuleContext(TfootTagOpenContext.class,0);
10601                }
10602                public TfootTagCloseContext tfootTagClose() {
10603                        return getRuleContext(TfootTagCloseContext.class,0);
10604                }
10605                public List<HtmlTagContext> htmlTag() {
10606                        return getRuleContexts(HtmlTagContext.class);
10607                }
10608                public HtmlTagContext htmlTag(int i) {
10609                        return getRuleContext(HtmlTagContext.class,i);
10610                }
10611                public List<SingletonTagContext> singletonTag() {
10612                        return getRuleContexts(SingletonTagContext.class);
10613                }
10614                public SingletonTagContext singletonTag(int i) {
10615                        return getRuleContext(SingletonTagContext.class,i);
10616                }
10617                public List<ParagraphContext> paragraph() {
10618                        return getRuleContexts(ParagraphContext.class);
10619                }
10620                public ParagraphContext paragraph(int i) {
10621                        return getRuleContext(ParagraphContext.class,i);
10622                }
10623                public List<LiContext> li() {
10624                        return getRuleContexts(LiContext.class);
10625                }
10626                public LiContext li(int i) {
10627                        return getRuleContext(LiContext.class,i);
10628                }
10629                public List<TrContext> tr() {
10630                        return getRuleContexts(TrContext.class);
10631                }
10632                public TrContext tr(int i) {
10633                        return getRuleContext(TrContext.class,i);
10634                }
10635                public List<TdContext> td() {
10636                        return getRuleContexts(TdContext.class);
10637                }
10638                public TdContext td(int i) {
10639                        return getRuleContext(TdContext.class,i);
10640                }
10641                public List<ThContext> th() {
10642                        return getRuleContexts(ThContext.class);
10643                }
10644                public ThContext th(int i) {
10645                        return getRuleContext(ThContext.class,i);
10646                }
10647                public List<BodyContext> body() {
10648                        return getRuleContexts(BodyContext.class);
10649                }
10650                public BodyContext body(int i) {
10651                        return getRuleContext(BodyContext.class,i);
10652                }
10653                public List<ColgroupContext> colgroup() {
10654                        return getRuleContexts(ColgroupContext.class);
10655                }
10656                public ColgroupContext colgroup(int i) {
10657                        return getRuleContext(ColgroupContext.class,i);
10658                }
10659                public List<DdContext> dd() {
10660                        return getRuleContexts(DdContext.class);
10661                }
10662                public DdContext dd(int i) {
10663                        return getRuleContext(DdContext.class,i);
10664                }
10665                public List<DtContext> dt() {
10666                        return getRuleContexts(DtContext.class);
10667                }
10668                public DtContext dt(int i) {
10669                        return getRuleContext(DtContext.class,i);
10670                }
10671                public List<HeadContext> head() {
10672                        return getRuleContexts(HeadContext.class);
10673                }
10674                public HeadContext head(int i) {
10675                        return getRuleContext(HeadContext.class,i);
10676                }
10677                public List<HtmlContext> html() {
10678                        return getRuleContexts(HtmlContext.class);
10679                }
10680                public HtmlContext html(int i) {
10681                        return getRuleContext(HtmlContext.class,i);
10682                }
10683                public List<OptionContext> option() {
10684                        return getRuleContexts(OptionContext.class);
10685                }
10686                public OptionContext option(int i) {
10687                        return getRuleContext(OptionContext.class,i);
10688                }
10689                public List<TbodyContext> tbody() {
10690                        return getRuleContexts(TbodyContext.class);
10691                }
10692                public TbodyContext tbody(int i) {
10693                        return getRuleContext(TbodyContext.class,i);
10694                }
10695                public List<TheadContext> thead() {
10696                        return getRuleContexts(TheadContext.class);
10697                }
10698                public TheadContext thead(int i) {
10699                        return getRuleContext(TheadContext.class,i);
10700                }
10701                public List<PTagOpenContext> pTagOpen() {
10702                        return getRuleContexts(PTagOpenContext.class);
10703                }
10704                public PTagOpenContext pTagOpen(int i) {
10705                        return getRuleContext(PTagOpenContext.class,i);
10706                }
10707                public List<LiTagOpenContext> liTagOpen() {
10708                        return getRuleContexts(LiTagOpenContext.class);
10709                }
10710                public LiTagOpenContext liTagOpen(int i) {
10711                        return getRuleContext(LiTagOpenContext.class,i);
10712                }
10713                public List<TrTagOpenContext> trTagOpen() {
10714                        return getRuleContexts(TrTagOpenContext.class);
10715                }
10716                public TrTagOpenContext trTagOpen(int i) {
10717                        return getRuleContext(TrTagOpenContext.class,i);
10718                }
10719                public List<TdTagOpenContext> tdTagOpen() {
10720                        return getRuleContexts(TdTagOpenContext.class);
10721                }
10722                public TdTagOpenContext tdTagOpen(int i) {
10723                        return getRuleContext(TdTagOpenContext.class,i);
10724                }
10725                public List<ThTagOpenContext> thTagOpen() {
10726                        return getRuleContexts(ThTagOpenContext.class);
10727                }
10728                public ThTagOpenContext thTagOpen(int i) {
10729                        return getRuleContext(ThTagOpenContext.class,i);
10730                }
10731                public List<BodyTagOpenContext> bodyTagOpen() {
10732                        return getRuleContexts(BodyTagOpenContext.class);
10733                }
10734                public BodyTagOpenContext bodyTagOpen(int i) {
10735                        return getRuleContext(BodyTagOpenContext.class,i);
10736                }
10737                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10738                        return getRuleContexts(ColgroupTagOpenContext.class);
10739                }
10740                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10741                        return getRuleContext(ColgroupTagOpenContext.class,i);
10742                }
10743                public List<DdTagOpenContext> ddTagOpen() {
10744                        return getRuleContexts(DdTagOpenContext.class);
10745                }
10746                public DdTagOpenContext ddTagOpen(int i) {
10747                        return getRuleContext(DdTagOpenContext.class,i);
10748                }
10749                public List<DtTagOpenContext> dtTagOpen() {
10750                        return getRuleContexts(DtTagOpenContext.class);
10751                }
10752                public DtTagOpenContext dtTagOpen(int i) {
10753                        return getRuleContext(DtTagOpenContext.class,i);
10754                }
10755                public List<HeadTagOpenContext> headTagOpen() {
10756                        return getRuleContexts(HeadTagOpenContext.class);
10757                }
10758                public HeadTagOpenContext headTagOpen(int i) {
10759                        return getRuleContext(HeadTagOpenContext.class,i);
10760                }
10761                public List<HtmlTagOpenContext> htmlTagOpen() {
10762                        return getRuleContexts(HtmlTagOpenContext.class);
10763                }
10764                public HtmlTagOpenContext htmlTagOpen(int i) {
10765                        return getRuleContext(HtmlTagOpenContext.class,i);
10766                }
10767                public List<OptionTagOpenContext> optionTagOpen() {
10768                        return getRuleContexts(OptionTagOpenContext.class);
10769                }
10770                public OptionTagOpenContext optionTagOpen(int i) {
10771                        return getRuleContext(OptionTagOpenContext.class,i);
10772                }
10773                public List<TbodyTagOpenContext> tbodyTagOpen() {
10774                        return getRuleContexts(TbodyTagOpenContext.class);
10775                }
10776                public TbodyTagOpenContext tbodyTagOpen(int i) {
10777                        return getRuleContext(TbodyTagOpenContext.class,i);
10778                }
10779                public List<TheadTagOpenContext> theadTagOpen() {
10780                        return getRuleContexts(TheadTagOpenContext.class);
10781                }
10782                public TheadTagOpenContext theadTagOpen(int i) {
10783                        return getRuleContext(TheadTagOpenContext.class,i);
10784                }
10785                public List<HtmlCommentContext> htmlComment() {
10786                        return getRuleContexts(HtmlCommentContext.class);
10787                }
10788                public HtmlCommentContext htmlComment(int i) {
10789                        return getRuleContext(HtmlCommentContext.class,i);
10790                }
10791                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10792                public TerminalNode CDATA(int i) {
10793                        return getToken(JavadocParser.CDATA, i);
10794                }
10795                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10796                public TerminalNode NEWLINE(int i) {
10797                        return getToken(JavadocParser.NEWLINE, i);
10798                }
10799                public List<TextContext> text() {
10800                        return getRuleContexts(TextContext.class);
10801                }
10802                public TextContext text(int i) {
10803                        return getRuleContext(TextContext.class,i);
10804                }
10805                public List<JavadocInlineTagContext> javadocInlineTag() {
10806                        return getRuleContexts(JavadocInlineTagContext.class);
10807                }
10808                public JavadocInlineTagContext javadocInlineTag(int i) {
10809                        return getRuleContext(JavadocInlineTagContext.class,i);
10810                }
10811                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10812                public TerminalNode LEADING_ASTERISK(int i) {
10813                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10814                }
10815                public TfootContext(ParserRuleContext parent, int invokingState) {
10816                        super(parent, invokingState);
10817                }
10818                @Override public int getRuleIndex() { return RULE_tfoot; }
10819                @Override
10820                public void enterRule(ParseTreeListener listener) {
10821                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this);
10822                }
10823                @Override
10824                public void exitRule(ParseTreeListener listener) {
10825                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this);
10826                }
10827                @Override
10828                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10829                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this);
10830                        else return visitor.visitChildren(this);
10831                }
10832        }
10833
10834        public final TfootContext tfoot() throws RecognitionException {
10835                TfootContext _localctx = new TfootContext(_ctx, getState());
10836                enterRule(_localctx, 94, RULE_tfoot);
10837                try {
10838                        int _alt;
10839                        enterOuterAlt(_localctx, 1);
10840                        {
10841                        setState(1227);
10842                        tfootTagOpen();
10843                        setState(1267);
10844                        _errHandler.sync(this);
10845                        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10846                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10847                                if ( _alt==1 ) {
10848                                        {
10849                                        setState(1265);
10850                                        _errHandler.sync(this);
10851                                        switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
10852                                        case 1:
10853                                                {
10854                                                setState(1228);
10855                                                htmlTag();
10856                                                }
10857                                                break;
10858                                        case 2:
10859                                                {
10860                                                setState(1229);
10861                                                singletonTag();
10862                                                }
10863                                                break;
10864                                        case 3:
10865                                                {
10866                                                setState(1230);
10867                                                paragraph();
10868                                                }
10869                                                break;
10870                                        case 4:
10871                                                {
10872                                                setState(1231);
10873                                                li();
10874                                                }
10875                                                break;
10876                                        case 5:
10877                                                {
10878                                                setState(1232);
10879                                                tr();
10880                                                }
10881                                                break;
10882                                        case 6:
10883                                                {
10884                                                setState(1233);
10885                                                td();
10886                                                }
10887                                                break;
10888                                        case 7:
10889                                                {
10890                                                setState(1234);
10891                                                th();
10892                                                }
10893                                                break;
10894                                        case 8:
10895                                                {
10896                                                setState(1235);
10897                                                body();
10898                                                }
10899                                                break;
10900                                        case 9:
10901                                                {
10902                                                setState(1236);
10903                                                colgroup();
10904                                                }
10905                                                break;
10906                                        case 10:
10907                                                {
10908                                                setState(1237);
10909                                                dd();
10910                                                }
10911                                                break;
10912                                        case 11:
10913                                                {
10914                                                setState(1238);
10915                                                dt();
10916                                                }
10917                                                break;
10918                                        case 12:
10919                                                {
10920                                                setState(1239);
10921                                                head();
10922                                                }
10923                                                break;
10924                                        case 13:
10925                                                {
10926                                                setState(1240);
10927                                                html();
10928                                                }
10929                                                break;
10930                                        case 14:
10931                                                {
10932                                                setState(1241);
10933                                                option();
10934                                                }
10935                                                break;
10936                                        case 15:
10937                                                {
10938                                                setState(1242);
10939                                                tbody();
10940                                                }
10941                                                break;
10942                                        case 16:
10943                                                {
10944                                                setState(1243);
10945                                                thead();
10946                                                }
10947                                                break;
10948                                        case 17:
10949                                                {
10950                                                setState(1244);
10951                                                pTagOpen();
10952                                                }
10953                                                break;
10954                                        case 18:
10955                                                {
10956                                                setState(1245);
10957                                                liTagOpen();
10958                                                }
10959                                                break;
10960                                        case 19:
10961                                                {
10962                                                setState(1246);
10963                                                trTagOpen();
10964                                                }
10965                                                break;
10966                                        case 20:
10967                                                {
10968                                                setState(1247);
10969                                                tdTagOpen();
10970                                                }
10971                                                break;
10972                                        case 21:
10973                                                {
10974                                                setState(1248);
10975                                                thTagOpen();
10976                                                }
10977                                                break;
10978                                        case 22:
10979                                                {
10980                                                setState(1249);
10981                                                bodyTagOpen();
10982                                                }
10983                                                break;
10984                                        case 23:
10985                                                {
10986                                                setState(1250);
10987                                                colgroupTagOpen();
10988                                                }
10989                                                break;
10990                                        case 24:
10991                                                {
10992                                                setState(1251);
10993                                                ddTagOpen();
10994                                                }
10995                                                break;
10996                                        case 25:
10997                                                {
10998                                                setState(1252);
10999                                                dtTagOpen();
11000                                                }
11001                                                break;
11002                                        case 26:
11003                                                {
11004                                                setState(1253);
11005                                                headTagOpen();
11006                                                }
11007                                                break;
11008                                        case 27:
11009                                                {
11010                                                setState(1254);
11011                                                htmlTagOpen();
11012                                                }
11013                                                break;
11014                                        case 28:
11015                                                {
11016                                                setState(1255);
11017                                                optionTagOpen();
11018                                                }
11019                                                break;
11020                                        case 29:
11021                                                {
11022                                                setState(1256);
11023                                                tbodyTagOpen();
11024                                                }
11025                                                break;
11026                                        case 30:
11027                                                {
11028                                                setState(1257);
11029                                                theadTagOpen();
11030                                                }
11031                                                break;
11032                                        case 31:
11033                                                {
11034                                                {
11035                                                setState(1258);
11036                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11037                                                setState(1259);
11038                                                match(LEADING_ASTERISK);
11039                                                }
11040                                                }
11041                                                break;
11042                                        case 32:
11043                                                {
11044                                                setState(1260);
11045                                                htmlComment();
11046                                                }
11047                                                break;
11048                                        case 33:
11049                                                {
11050                                                setState(1261);
11051                                                match(CDATA);
11052                                                }
11053                                                break;
11054                                        case 34:
11055                                                {
11056                                                setState(1262);
11057                                                match(NEWLINE);
11058                                                }
11059                                                break;
11060                                        case 35:
11061                                                {
11062                                                setState(1263);
11063                                                text();
11064                                                }
11065                                                break;
11066                                        case 36:
11067                                                {
11068                                                setState(1264);
11069                                                javadocInlineTag();
11070                                                }
11071                                                break;
11072                                        }
11073                                        } 
11074                                }
11075                                setState(1269);
11076                                _errHandler.sync(this);
11077                                _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
11078                        }
11079                        setState(1270);
11080                        tfootTagClose();
11081                        }
11082                }
11083                catch (RecognitionException re) {
11084                        _localctx.exception = re;
11085                        _errHandler.reportError(this, re);
11086                        _errHandler.recover(this, re);
11087                }
11088                finally {
11089                        exitRule();
11090                }
11091                return _localctx;
11092        }
11093
11094        public static class TheadTagOpenContext extends ParserRuleContext {
11095                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11096                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11097                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11098                public List<AttributeContext> attribute() {
11099                        return getRuleContexts(AttributeContext.class);
11100                }
11101                public AttributeContext attribute(int i) {
11102                        return getRuleContext(AttributeContext.class,i);
11103                }
11104                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11105                public TerminalNode NEWLINE(int i) {
11106                        return getToken(JavadocParser.NEWLINE, i);
11107                }
11108                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11109                public TerminalNode LEADING_ASTERISK(int i) {
11110                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11111                }
11112                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11113                public TerminalNode WS(int i) {
11114                        return getToken(JavadocParser.WS, i);
11115                }
11116                public TheadTagOpenContext(ParserRuleContext parent, int invokingState) {
11117                        super(parent, invokingState);
11118                }
11119                @Override public int getRuleIndex() { return RULE_theadTagOpen; }
11120                @Override
11121                public void enterRule(ParseTreeListener listener) {
11122                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this);
11123                }
11124                @Override
11125                public void exitRule(ParseTreeListener listener) {
11126                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this);
11127                }
11128                @Override
11129                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11130                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this);
11131                        else return visitor.visitChildren(this);
11132                }
11133        }
11134
11135        public final TheadTagOpenContext theadTagOpen() throws RecognitionException {
11136                TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState());
11137                enterRule(_localctx, 96, RULE_theadTagOpen);
11138                int _la;
11139                try {
11140                        enterOuterAlt(_localctx, 1);
11141                        {
11142                        setState(1272);
11143                        match(OPEN);
11144                        setState(1273);
11145                        match(THEAD_HTML_TAG_NAME);
11146                        setState(1280);
11147                        _errHandler.sync(this);
11148                        _la = _input.LA(1);
11149                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11150                                {
11151                                setState(1278);
11152                                _errHandler.sync(this);
11153                                switch (_input.LA(1)) {
11154                                case HTML_TAG_NAME:
11155                                        {
11156                                        setState(1274);
11157                                        attribute();
11158                                        }
11159                                        break;
11160                                case NEWLINE:
11161                                        {
11162                                        setState(1275);
11163                                        match(NEWLINE);
11164                                        }
11165                                        break;
11166                                case LEADING_ASTERISK:
11167                                        {
11168                                        setState(1276);
11169                                        match(LEADING_ASTERISK);
11170                                        }
11171                                        break;
11172                                case WS:
11173                                        {
11174                                        setState(1277);
11175                                        match(WS);
11176                                        }
11177                                        break;
11178                                default:
11179                                        throw new NoViableAltException(this);
11180                                }
11181                                }
11182                                setState(1282);
11183                                _errHandler.sync(this);
11184                                _la = _input.LA(1);
11185                        }
11186                        setState(1283);
11187                        match(CLOSE);
11188                        }
11189                }
11190                catch (RecognitionException re) {
11191                        _localctx.exception = re;
11192                        _errHandler.reportError(this, re);
11193                        _errHandler.recover(this, re);
11194                }
11195                finally {
11196                        exitRule();
11197                }
11198                return _localctx;
11199        }
11200
11201        public static class TheadTagCloseContext extends ParserRuleContext {
11202                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11203                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
11204                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11205                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11206                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11207                public TerminalNode NEWLINE(int i) {
11208                        return getToken(JavadocParser.NEWLINE, i);
11209                }
11210                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11211                public TerminalNode LEADING_ASTERISK(int i) {
11212                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11213                }
11214                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11215                public TerminalNode WS(int i) {
11216                        return getToken(JavadocParser.WS, i);
11217                }
11218                public TheadTagCloseContext(ParserRuleContext parent, int invokingState) {
11219                        super(parent, invokingState);
11220                }
11221                @Override public int getRuleIndex() { return RULE_theadTagClose; }
11222                @Override
11223                public void enterRule(ParseTreeListener listener) {
11224                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this);
11225                }
11226                @Override
11227                public void exitRule(ParseTreeListener listener) {
11228                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this);
11229                }
11230                @Override
11231                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11232                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this);
11233                        else return visitor.visitChildren(this);
11234                }
11235        }
11236
11237        public final TheadTagCloseContext theadTagClose() throws RecognitionException {
11238                TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState());
11239                enterRule(_localctx, 98, RULE_theadTagClose);
11240                int _la;
11241                try {
11242                        enterOuterAlt(_localctx, 1);
11243                        {
11244                        setState(1285);
11245                        match(OPEN);
11246                        setState(1286);
11247                        match(SLASH);
11248                        setState(1287);
11249                        match(THEAD_HTML_TAG_NAME);
11250                        setState(1291);
11251                        _errHandler.sync(this);
11252                        _la = _input.LA(1);
11253                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
11254                                {
11255                                {
11256                                setState(1288);
11257                                _la = _input.LA(1);
11258                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
11259                                _errHandler.recoverInline(this);
11260                                }
11261                                else {
11262                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
11263                                        _errHandler.reportMatch(this);
11264                                        consume();
11265                                }
11266                                }
11267                                }
11268                                setState(1293);
11269                                _errHandler.sync(this);
11270                                _la = _input.LA(1);
11271                        }
11272                        setState(1294);
11273                        match(CLOSE);
11274                        }
11275                }
11276                catch (RecognitionException re) {
11277                        _localctx.exception = re;
11278                        _errHandler.reportError(this, re);
11279                        _errHandler.recover(this, re);
11280                }
11281                finally {
11282                        exitRule();
11283                }
11284                return _localctx;
11285        }
11286
11287        public static class TheadContext extends ParserRuleContext {
11288                public TheadTagOpenContext theadTagOpen() {
11289                        return getRuleContext(TheadTagOpenContext.class,0);
11290                }
11291                public TheadTagCloseContext theadTagClose() {
11292                        return getRuleContext(TheadTagCloseContext.class,0);
11293                }
11294                public List<HtmlTagContext> htmlTag() {
11295                        return getRuleContexts(HtmlTagContext.class);
11296                }
11297                public HtmlTagContext htmlTag(int i) {
11298                        return getRuleContext(HtmlTagContext.class,i);
11299                }
11300                public List<SingletonTagContext> singletonTag() {
11301                        return getRuleContexts(SingletonTagContext.class);
11302                }
11303                public SingletonTagContext singletonTag(int i) {
11304                        return getRuleContext(SingletonTagContext.class,i);
11305                }
11306                public List<ParagraphContext> paragraph() {
11307                        return getRuleContexts(ParagraphContext.class);
11308                }
11309                public ParagraphContext paragraph(int i) {
11310                        return getRuleContext(ParagraphContext.class,i);
11311                }
11312                public List<LiContext> li() {
11313                        return getRuleContexts(LiContext.class);
11314                }
11315                public LiContext li(int i) {
11316                        return getRuleContext(LiContext.class,i);
11317                }
11318                public List<TrContext> tr() {
11319                        return getRuleContexts(TrContext.class);
11320                }
11321                public TrContext tr(int i) {
11322                        return getRuleContext(TrContext.class,i);
11323                }
11324                public List<TdContext> td() {
11325                        return getRuleContexts(TdContext.class);
11326                }
11327                public TdContext td(int i) {
11328                        return getRuleContext(TdContext.class,i);
11329                }
11330                public List<ThContext> th() {
11331                        return getRuleContexts(ThContext.class);
11332                }
11333                public ThContext th(int i) {
11334                        return getRuleContext(ThContext.class,i);
11335                }
11336                public List<BodyContext> body() {
11337                        return getRuleContexts(BodyContext.class);
11338                }
11339                public BodyContext body(int i) {
11340                        return getRuleContext(BodyContext.class,i);
11341                }
11342                public List<ColgroupContext> colgroup() {
11343                        return getRuleContexts(ColgroupContext.class);
11344                }
11345                public ColgroupContext colgroup(int i) {
11346                        return getRuleContext(ColgroupContext.class,i);
11347                }
11348                public List<DdContext> dd() {
11349                        return getRuleContexts(DdContext.class);
11350                }
11351                public DdContext dd(int i) {
11352                        return getRuleContext(DdContext.class,i);
11353                }
11354                public List<DtContext> dt() {
11355                        return getRuleContexts(DtContext.class);
11356                }
11357                public DtContext dt(int i) {
11358                        return getRuleContext(DtContext.class,i);
11359                }
11360                public List<HeadContext> head() {
11361                        return getRuleContexts(HeadContext.class);
11362                }
11363                public HeadContext head(int i) {
11364                        return getRuleContext(HeadContext.class,i);
11365                }
11366                public List<HtmlContext> html() {
11367                        return getRuleContexts(HtmlContext.class);
11368                }
11369                public HtmlContext html(int i) {
11370                        return getRuleContext(HtmlContext.class,i);
11371                }
11372                public List<OptionContext> option() {
11373                        return getRuleContexts(OptionContext.class);
11374                }
11375                public OptionContext option(int i) {
11376                        return getRuleContext(OptionContext.class,i);
11377                }
11378                public List<TbodyContext> tbody() {
11379                        return getRuleContexts(TbodyContext.class);
11380                }
11381                public TbodyContext tbody(int i) {
11382                        return getRuleContext(TbodyContext.class,i);
11383                }
11384                public List<TfootContext> tfoot() {
11385                        return getRuleContexts(TfootContext.class);
11386                }
11387                public TfootContext tfoot(int i) {
11388                        return getRuleContext(TfootContext.class,i);
11389                }
11390                public List<PTagOpenContext> pTagOpen() {
11391                        return getRuleContexts(PTagOpenContext.class);
11392                }
11393                public PTagOpenContext pTagOpen(int i) {
11394                        return getRuleContext(PTagOpenContext.class,i);
11395                }
11396                public List<LiTagOpenContext> liTagOpen() {
11397                        return getRuleContexts(LiTagOpenContext.class);
11398                }
11399                public LiTagOpenContext liTagOpen(int i) {
11400                        return getRuleContext(LiTagOpenContext.class,i);
11401                }
11402                public List<TrTagOpenContext> trTagOpen() {
11403                        return getRuleContexts(TrTagOpenContext.class);
11404                }
11405                public TrTagOpenContext trTagOpen(int i) {
11406                        return getRuleContext(TrTagOpenContext.class,i);
11407                }
11408                public List<TdTagOpenContext> tdTagOpen() {
11409                        return getRuleContexts(TdTagOpenContext.class);
11410                }
11411                public TdTagOpenContext tdTagOpen(int i) {
11412                        return getRuleContext(TdTagOpenContext.class,i);
11413                }
11414                public List<ThTagOpenContext> thTagOpen() {
11415                        return getRuleContexts(ThTagOpenContext.class);
11416                }
11417                public ThTagOpenContext thTagOpen(int i) {
11418                        return getRuleContext(ThTagOpenContext.class,i);
11419                }
11420                public List<BodyTagOpenContext> bodyTagOpen() {
11421                        return getRuleContexts(BodyTagOpenContext.class);
11422                }
11423                public BodyTagOpenContext bodyTagOpen(int i) {
11424                        return getRuleContext(BodyTagOpenContext.class,i);
11425                }
11426                public List<ColgroupTagOpenContext> colgroupTagOpen() {
11427                        return getRuleContexts(ColgroupTagOpenContext.class);
11428                }
11429                public ColgroupTagOpenContext colgroupTagOpen(int i) {
11430                        return getRuleContext(ColgroupTagOpenContext.class,i);
11431                }
11432                public List<DdTagOpenContext> ddTagOpen() {
11433                        return getRuleContexts(DdTagOpenContext.class);
11434                }
11435                public DdTagOpenContext ddTagOpen(int i) {
11436                        return getRuleContext(DdTagOpenContext.class,i);
11437                }
11438                public List<DtTagOpenContext> dtTagOpen() {
11439                        return getRuleContexts(DtTagOpenContext.class);
11440                }
11441                public DtTagOpenContext dtTagOpen(int i) {
11442                        return getRuleContext(DtTagOpenContext.class,i);
11443                }
11444                public List<HeadTagOpenContext> headTagOpen() {
11445                        return getRuleContexts(HeadTagOpenContext.class);
11446                }
11447                public HeadTagOpenContext headTagOpen(int i) {
11448                        return getRuleContext(HeadTagOpenContext.class,i);
11449                }
11450                public List<HtmlTagOpenContext> htmlTagOpen() {
11451                        return getRuleContexts(HtmlTagOpenContext.class);
11452                }
11453                public HtmlTagOpenContext htmlTagOpen(int i) {
11454                        return getRuleContext(HtmlTagOpenContext.class,i);
11455                }
11456                public List<OptionTagOpenContext> optionTagOpen() {
11457                        return getRuleContexts(OptionTagOpenContext.class);
11458                }
11459                public OptionTagOpenContext optionTagOpen(int i) {
11460                        return getRuleContext(OptionTagOpenContext.class,i);
11461                }
11462                public List<TbodyTagOpenContext> tbodyTagOpen() {
11463                        return getRuleContexts(TbodyTagOpenContext.class);
11464                }
11465                public TbodyTagOpenContext tbodyTagOpen(int i) {
11466                        return getRuleContext(TbodyTagOpenContext.class,i);
11467                }
11468                public List<TfootTagOpenContext> tfootTagOpen() {
11469                        return getRuleContexts(TfootTagOpenContext.class);
11470                }
11471                public TfootTagOpenContext tfootTagOpen(int i) {
11472                        return getRuleContext(TfootTagOpenContext.class,i);
11473                }
11474                public List<HtmlCommentContext> htmlComment() {
11475                        return getRuleContexts(HtmlCommentContext.class);
11476                }
11477                public HtmlCommentContext htmlComment(int i) {
11478                        return getRuleContext(HtmlCommentContext.class,i);
11479                }
11480                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
11481                public TerminalNode CDATA(int i) {
11482                        return getToken(JavadocParser.CDATA, i);
11483                }
11484                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11485                public TerminalNode NEWLINE(int i) {
11486                        return getToken(JavadocParser.NEWLINE, i);
11487                }
11488                public List<TextContext> text() {
11489                        return getRuleContexts(TextContext.class);
11490                }
11491                public TextContext text(int i) {
11492                        return getRuleContext(TextContext.class,i);
11493                }
11494                public List<JavadocInlineTagContext> javadocInlineTag() {
11495                        return getRuleContexts(JavadocInlineTagContext.class);
11496                }
11497                public JavadocInlineTagContext javadocInlineTag(int i) {
11498                        return getRuleContext(JavadocInlineTagContext.class,i);
11499                }
11500                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11501                public TerminalNode LEADING_ASTERISK(int i) {
11502                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11503                }
11504                public TheadContext(ParserRuleContext parent, int invokingState) {
11505                        super(parent, invokingState);
11506                }
11507                @Override public int getRuleIndex() { return RULE_thead; }
11508                @Override
11509                public void enterRule(ParseTreeListener listener) {
11510                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this);
11511                }
11512                @Override
11513                public void exitRule(ParseTreeListener listener) {
11514                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this);
11515                }
11516                @Override
11517                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11518                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this);
11519                        else return visitor.visitChildren(this);
11520                }
11521        }
11522
11523        public final TheadContext thead() throws RecognitionException {
11524                TheadContext _localctx = new TheadContext(_ctx, getState());
11525                enterRule(_localctx, 100, RULE_thead);
11526                try {
11527                        int _alt;
11528                        enterOuterAlt(_localctx, 1);
11529                        {
11530                        setState(1296);
11531                        theadTagOpen();
11532                        setState(1336);
11533                        _errHandler.sync(this);
11534                        _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11535                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11536                                if ( _alt==1 ) {
11537                                        {
11538                                        setState(1334);
11539                                        _errHandler.sync(this);
11540                                        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
11541                                        case 1:
11542                                                {
11543                                                setState(1297);
11544                                                htmlTag();
11545                                                }
11546                                                break;
11547                                        case 2:
11548                                                {
11549                                                setState(1298);
11550                                                singletonTag();
11551                                                }
11552                                                break;
11553                                        case 3:
11554                                                {
11555                                                setState(1299);
11556                                                paragraph();
11557                                                }
11558                                                break;
11559                                        case 4:
11560                                                {
11561                                                setState(1300);
11562                                                li();
11563                                                }
11564                                                break;
11565                                        case 5:
11566                                                {
11567                                                setState(1301);
11568                                                tr();
11569                                                }
11570                                                break;
11571                                        case 6:
11572                                                {
11573                                                setState(1302);
11574                                                td();
11575                                                }
11576                                                break;
11577                                        case 7:
11578                                                {
11579                                                setState(1303);
11580                                                th();
11581                                                }
11582                                                break;
11583                                        case 8:
11584                                                {
11585                                                setState(1304);
11586                                                body();
11587                                                }
11588                                                break;
11589                                        case 9:
11590                                                {
11591                                                setState(1305);
11592                                                colgroup();
11593                                                }
11594                                                break;
11595                                        case 10:
11596                                                {
11597                                                setState(1306);
11598                                                dd();
11599                                                }
11600                                                break;
11601                                        case 11:
11602                                                {
11603                                                setState(1307);
11604                                                dt();
11605                                                }
11606                                                break;
11607                                        case 12:
11608                                                {
11609                                                setState(1308);
11610                                                head();
11611                                                }
11612                                                break;
11613                                        case 13:
11614                                                {
11615                                                setState(1309);
11616                                                html();
11617                                                }
11618                                                break;
11619                                        case 14:
11620                                                {
11621                                                setState(1310);
11622                                                option();
11623                                                }
11624                                                break;
11625                                        case 15:
11626                                                {
11627                                                setState(1311);
11628                                                tbody();
11629                                                }
11630                                                break;
11631                                        case 16:
11632                                                {
11633                                                setState(1312);
11634                                                tfoot();
11635                                                }
11636                                                break;
11637                                        case 17:
11638                                                {
11639                                                setState(1313);
11640                                                pTagOpen();
11641                                                }
11642                                                break;
11643                                        case 18:
11644                                                {
11645                                                setState(1314);
11646                                                liTagOpen();
11647                                                }
11648                                                break;
11649                                        case 19:
11650                                                {
11651                                                setState(1315);
11652                                                trTagOpen();
11653                                                }
11654                                                break;
11655                                        case 20:
11656                                                {
11657                                                setState(1316);
11658                                                tdTagOpen();
11659                                                }
11660                                                break;
11661                                        case 21:
11662                                                {
11663                                                setState(1317);
11664                                                thTagOpen();
11665                                                }
11666                                                break;
11667                                        case 22:
11668                                                {
11669                                                setState(1318);
11670                                                bodyTagOpen();
11671                                                }
11672                                                break;
11673                                        case 23:
11674                                                {
11675                                                setState(1319);
11676                                                colgroupTagOpen();
11677                                                }
11678                                                break;
11679                                        case 24:
11680                                                {
11681                                                setState(1320);
11682                                                ddTagOpen();
11683                                                }
11684                                                break;
11685                                        case 25:
11686                                                {
11687                                                setState(1321);
11688                                                dtTagOpen();
11689                                                }
11690                                                break;
11691                                        case 26:
11692                                                {
11693                                                setState(1322);
11694                                                headTagOpen();
11695                                                }
11696                                                break;
11697                                        case 27:
11698                                                {
11699                                                setState(1323);
11700                                                htmlTagOpen();
11701                                                }
11702                                                break;
11703                                        case 28:
11704                                                {
11705                                                setState(1324);
11706                                                optionTagOpen();
11707                                                }
11708                                                break;
11709                                        case 29:
11710                                                {
11711                                                setState(1325);
11712                                                tbodyTagOpen();
11713                                                }
11714                                                break;
11715                                        case 30:
11716                                                {
11717                                                setState(1326);
11718                                                tfootTagOpen();
11719                                                }
11720                                                break;
11721                                        case 31:
11722                                                {
11723                                                {
11724                                                setState(1327);
11725                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11726                                                setState(1328);
11727                                                match(LEADING_ASTERISK);
11728                                                }
11729                                                }
11730                                                break;
11731                                        case 32:
11732                                                {
11733                                                setState(1329);
11734                                                htmlComment();
11735                                                }
11736                                                break;
11737                                        case 33:
11738                                                {
11739                                                setState(1330);
11740                                                match(CDATA);
11741                                                }
11742                                                break;
11743                                        case 34:
11744                                                {
11745                                                setState(1331);
11746                                                match(NEWLINE);
11747                                                }
11748                                                break;
11749                                        case 35:
11750                                                {
11751                                                setState(1332);
11752                                                text();
11753                                                }
11754                                                break;
11755                                        case 36:
11756                                                {
11757                                                setState(1333);
11758                                                javadocInlineTag();
11759                                                }
11760                                                break;
11761                                        }
11762                                        } 
11763                                }
11764                                setState(1338);
11765                                _errHandler.sync(this);
11766                                _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11767                        }
11768                        setState(1339);
11769                        theadTagClose();
11770                        }
11771                }
11772                catch (RecognitionException re) {
11773                        _localctx.exception = re;
11774                        _errHandler.reportError(this, re);
11775                        _errHandler.recover(this, re);
11776                }
11777                finally {
11778                        exitRule();
11779                }
11780                return _localctx;
11781        }
11782
11783        public static class SingletonElementContext extends ParserRuleContext {
11784                public SingletonTagContext singletonTag() {
11785                        return getRuleContext(SingletonTagContext.class,0);
11786                }
11787                public AreaTagContext areaTag() {
11788                        return getRuleContext(AreaTagContext.class,0);
11789                }
11790                public BaseTagContext baseTag() {
11791                        return getRuleContext(BaseTagContext.class,0);
11792                }
11793                public BasefontTagContext basefontTag() {
11794                        return getRuleContext(BasefontTagContext.class,0);
11795                }
11796                public BrTagContext brTag() {
11797                        return getRuleContext(BrTagContext.class,0);
11798                }
11799                public ColTagContext colTag() {
11800                        return getRuleContext(ColTagContext.class,0);
11801                }
11802                public FrameTagContext frameTag() {
11803                        return getRuleContext(FrameTagContext.class,0);
11804                }
11805                public HrTagContext hrTag() {
11806                        return getRuleContext(HrTagContext.class,0);
11807                }
11808                public ImgTagContext imgTag() {
11809                        return getRuleContext(ImgTagContext.class,0);
11810                }
11811                public InputTagContext inputTag() {
11812                        return getRuleContext(InputTagContext.class,0);
11813                }
11814                public IsindexTagContext isindexTag() {
11815                        return getRuleContext(IsindexTagContext.class,0);
11816                }
11817                public LinkTagContext linkTag() {
11818                        return getRuleContext(LinkTagContext.class,0);
11819                }
11820                public MetaTagContext metaTag() {
11821                        return getRuleContext(MetaTagContext.class,0);
11822                }
11823                public ParamTagContext paramTag() {
11824                        return getRuleContext(ParamTagContext.class,0);
11825                }
11826                public WrongSinletonTagContext wrongSinletonTag() {
11827                        return getRuleContext(WrongSinletonTagContext.class,0);
11828                }
11829                public SingletonElementContext(ParserRuleContext parent, int invokingState) {
11830                        super(parent, invokingState);
11831                }
11832                @Override public int getRuleIndex() { return RULE_singletonElement; }
11833                @Override
11834                public void enterRule(ParseTreeListener listener) {
11835                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this);
11836                }
11837                @Override
11838                public void exitRule(ParseTreeListener listener) {
11839                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this);
11840                }
11841                @Override
11842                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11843                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this);
11844                        else return visitor.visitChildren(this);
11845                }
11846        }
11847
11848        public final SingletonElementContext singletonElement() throws RecognitionException {
11849                SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState());
11850                enterRule(_localctx, 102, RULE_singletonElement);
11851                try {
11852                        setState(1356);
11853                        _errHandler.sync(this);
11854                        switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
11855                        case 1:
11856                                enterOuterAlt(_localctx, 1);
11857                                {
11858                                setState(1341);
11859                                singletonTag();
11860                                }
11861                                break;
11862                        case 2:
11863                                enterOuterAlt(_localctx, 2);
11864                                {
11865                                setState(1342);
11866                                areaTag();
11867                                }
11868                                break;
11869                        case 3:
11870                                enterOuterAlt(_localctx, 3);
11871                                {
11872                                setState(1343);
11873                                baseTag();
11874                                }
11875                                break;
11876                        case 4:
11877                                enterOuterAlt(_localctx, 4);
11878                                {
11879                                setState(1344);
11880                                basefontTag();
11881                                }
11882                                break;
11883                        case 5:
11884                                enterOuterAlt(_localctx, 5);
11885                                {
11886                                setState(1345);
11887                                brTag();
11888                                }
11889                                break;
11890                        case 6:
11891                                enterOuterAlt(_localctx, 6);
11892                                {
11893                                setState(1346);
11894                                colTag();
11895                                }
11896                                break;
11897                        case 7:
11898                                enterOuterAlt(_localctx, 7);
11899                                {
11900                                setState(1347);
11901                                frameTag();
11902                                }
11903                                break;
11904                        case 8:
11905                                enterOuterAlt(_localctx, 8);
11906                                {
11907                                setState(1348);
11908                                hrTag();
11909                                }
11910                                break;
11911                        case 9:
11912                                enterOuterAlt(_localctx, 9);
11913                                {
11914                                setState(1349);
11915                                imgTag();
11916                                }
11917                                break;
11918                        case 10:
11919                                enterOuterAlt(_localctx, 10);
11920                                {
11921                                setState(1350);
11922                                inputTag();
11923                                }
11924                                break;
11925                        case 11:
11926                                enterOuterAlt(_localctx, 11);
11927                                {
11928                                setState(1351);
11929                                isindexTag();
11930                                }
11931                                break;
11932                        case 12:
11933                                enterOuterAlt(_localctx, 12);
11934                                {
11935                                setState(1352);
11936                                linkTag();
11937                                }
11938                                break;
11939                        case 13:
11940                                enterOuterAlt(_localctx, 13);
11941                                {
11942                                setState(1353);
11943                                metaTag();
11944                                }
11945                                break;
11946                        case 14:
11947                                enterOuterAlt(_localctx, 14);
11948                                {
11949                                setState(1354);
11950                                paramTag();
11951                                }
11952                                break;
11953                        case 15:
11954                                enterOuterAlt(_localctx, 15);
11955                                {
11956                                setState(1355);
11957                                wrongSinletonTag();
11958                                }
11959                                break;
11960                        }
11961                }
11962                catch (RecognitionException re) {
11963                        _localctx.exception = re;
11964                        _errHandler.reportError(this, re);
11965                        _errHandler.recover(this, re);
11966                }
11967                finally {
11968                        exitRule();
11969                }
11970                return _localctx;
11971        }
11972
11973        public static class SingletonTagContext extends ParserRuleContext {
11974                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11975                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11976                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
11977                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
11978                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
11979                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
11980                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
11981                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
11982                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
11983                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
11984                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
11985                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
11986                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
11987                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
11988                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
11989                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
11990                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
11991                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11992                public List<AttributeContext> attribute() {
11993                        return getRuleContexts(AttributeContext.class);
11994                }
11995                public AttributeContext attribute(int i) {
11996                        return getRuleContext(AttributeContext.class,i);
11997                }
11998                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11999                public TerminalNode NEWLINE(int i) {
12000                        return getToken(JavadocParser.NEWLINE, i);
12001                }
12002                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12003                public TerminalNode LEADING_ASTERISK(int i) {
12004                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12005                }
12006                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12007                public TerminalNode WS(int i) {
12008                        return getToken(JavadocParser.WS, i);
12009                }
12010                public SingletonTagContext(ParserRuleContext parent, int invokingState) {
12011                        super(parent, invokingState);
12012                }
12013                @Override public int getRuleIndex() { return RULE_singletonTag; }
12014                @Override
12015                public void enterRule(ParseTreeListener listener) {
12016                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this);
12017                }
12018                @Override
12019                public void exitRule(ParseTreeListener listener) {
12020                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this);
12021                }
12022                @Override
12023                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12024                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this);
12025                        else return visitor.visitChildren(this);
12026                }
12027        }
12028
12029        public final SingletonTagContext singletonTag() throws RecognitionException {
12030                SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState());
12031                enterRule(_localctx, 104, RULE_singletonTag);
12032                int _la;
12033                try {
12034                        enterOuterAlt(_localctx, 1);
12035                        {
12036                        setState(1358);
12037                        match(OPEN);
12038                        setState(1359);
12039                        _la = _input.LA(1);
12040                        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)) ) {
12041                        _errHandler.recoverInline(this);
12042                        }
12043                        else {
12044                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12045                                _errHandler.reportMatch(this);
12046                                consume();
12047                        }
12048                        setState(1366);
12049                        _errHandler.sync(this);
12050                        _la = _input.LA(1);
12051                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12052                                {
12053                                setState(1364);
12054                                _errHandler.sync(this);
12055                                switch (_input.LA(1)) {
12056                                case HTML_TAG_NAME:
12057                                        {
12058                                        setState(1360);
12059                                        attribute();
12060                                        }
12061                                        break;
12062                                case NEWLINE:
12063                                        {
12064                                        setState(1361);
12065                                        match(NEWLINE);
12066                                        }
12067                                        break;
12068                                case LEADING_ASTERISK:
12069                                        {
12070                                        setState(1362);
12071                                        match(LEADING_ASTERISK);
12072                                        }
12073                                        break;
12074                                case WS:
12075                                        {
12076                                        setState(1363);
12077                                        match(WS);
12078                                        }
12079                                        break;
12080                                default:
12081                                        throw new NoViableAltException(this);
12082                                }
12083                                }
12084                                setState(1368);
12085                                _errHandler.sync(this);
12086                                _la = _input.LA(1);
12087                        }
12088                        setState(1369);
12089                        match(SLASH_CLOSE);
12090                        }
12091                }
12092                catch (RecognitionException re) {
12093                        _localctx.exception = re;
12094                        _errHandler.reportError(this, re);
12095                        _errHandler.recover(this, re);
12096                }
12097                finally {
12098                        exitRule();
12099                }
12100                return _localctx;
12101        }
12102
12103        public static class AreaTagContext extends ParserRuleContext {
12104                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12105                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
12106                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12107                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12108                public List<AttributeContext> attribute() {
12109                        return getRuleContexts(AttributeContext.class);
12110                }
12111                public AttributeContext attribute(int i) {
12112                        return getRuleContext(AttributeContext.class,i);
12113                }
12114                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12115                public TerminalNode NEWLINE(int i) {
12116                        return getToken(JavadocParser.NEWLINE, i);
12117                }
12118                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12119                public TerminalNode LEADING_ASTERISK(int i) {
12120                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12121                }
12122                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12123                public TerminalNode WS(int i) {
12124                        return getToken(JavadocParser.WS, i);
12125                }
12126                public AreaTagContext(ParserRuleContext parent, int invokingState) {
12127                        super(parent, invokingState);
12128                }
12129                @Override public int getRuleIndex() { return RULE_areaTag; }
12130                @Override
12131                public void enterRule(ParseTreeListener listener) {
12132                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this);
12133                }
12134                @Override
12135                public void exitRule(ParseTreeListener listener) {
12136                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this);
12137                }
12138                @Override
12139                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12140                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this);
12141                        else return visitor.visitChildren(this);
12142                }
12143        }
12144
12145        public final AreaTagContext areaTag() throws RecognitionException {
12146                AreaTagContext _localctx = new AreaTagContext(_ctx, getState());
12147                enterRule(_localctx, 106, RULE_areaTag);
12148                int _la;
12149                try {
12150                        enterOuterAlt(_localctx, 1);
12151                        {
12152                        setState(1371);
12153                        match(OPEN);
12154                        setState(1372);
12155                        match(AREA_HTML_TAG_NAME);
12156                        setState(1379);
12157                        _errHandler.sync(this);
12158                        _la = _input.LA(1);
12159                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12160                                {
12161                                setState(1377);
12162                                _errHandler.sync(this);
12163                                switch (_input.LA(1)) {
12164                                case HTML_TAG_NAME:
12165                                        {
12166                                        setState(1373);
12167                                        attribute();
12168                                        }
12169                                        break;
12170                                case NEWLINE:
12171                                        {
12172                                        setState(1374);
12173                                        match(NEWLINE);
12174                                        }
12175                                        break;
12176                                case LEADING_ASTERISK:
12177                                        {
12178                                        setState(1375);
12179                                        match(LEADING_ASTERISK);
12180                                        }
12181                                        break;
12182                                case WS:
12183                                        {
12184                                        setState(1376);
12185                                        match(WS);
12186                                        }
12187                                        break;
12188                                default:
12189                                        throw new NoViableAltException(this);
12190                                }
12191                                }
12192                                setState(1381);
12193                                _errHandler.sync(this);
12194                                _la = _input.LA(1);
12195                        }
12196                        setState(1382);
12197                        _la = _input.LA(1);
12198                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12199                        _errHandler.recoverInline(this);
12200                        }
12201                        else {
12202                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12203                                _errHandler.reportMatch(this);
12204                                consume();
12205                        }
12206                        }
12207                }
12208                catch (RecognitionException re) {
12209                        _localctx.exception = re;
12210                        _errHandler.reportError(this, re);
12211                        _errHandler.recover(this, re);
12212                }
12213                finally {
12214                        exitRule();
12215                }
12216                return _localctx;
12217        }
12218
12219        public static class BaseTagContext extends ParserRuleContext {
12220                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12221                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
12222                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12223                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12224                public List<AttributeContext> attribute() {
12225                        return getRuleContexts(AttributeContext.class);
12226                }
12227                public AttributeContext attribute(int i) {
12228                        return getRuleContext(AttributeContext.class,i);
12229                }
12230                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12231                public TerminalNode NEWLINE(int i) {
12232                        return getToken(JavadocParser.NEWLINE, i);
12233                }
12234                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12235                public TerminalNode LEADING_ASTERISK(int i) {
12236                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12237                }
12238                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12239                public TerminalNode WS(int i) {
12240                        return getToken(JavadocParser.WS, i);
12241                }
12242                public BaseTagContext(ParserRuleContext parent, int invokingState) {
12243                        super(parent, invokingState);
12244                }
12245                @Override public int getRuleIndex() { return RULE_baseTag; }
12246                @Override
12247                public void enterRule(ParseTreeListener listener) {
12248                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this);
12249                }
12250                @Override
12251                public void exitRule(ParseTreeListener listener) {
12252                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this);
12253                }
12254                @Override
12255                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12256                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this);
12257                        else return visitor.visitChildren(this);
12258                }
12259        }
12260
12261        public final BaseTagContext baseTag() throws RecognitionException {
12262                BaseTagContext _localctx = new BaseTagContext(_ctx, getState());
12263                enterRule(_localctx, 108, RULE_baseTag);
12264                int _la;
12265                try {
12266                        enterOuterAlt(_localctx, 1);
12267                        {
12268                        setState(1384);
12269                        match(OPEN);
12270                        setState(1385);
12271                        match(BASE_HTML_TAG_NAME);
12272                        setState(1392);
12273                        _errHandler.sync(this);
12274                        _la = _input.LA(1);
12275                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12276                                {
12277                                setState(1390);
12278                                _errHandler.sync(this);
12279                                switch (_input.LA(1)) {
12280                                case HTML_TAG_NAME:
12281                                        {
12282                                        setState(1386);
12283                                        attribute();
12284                                        }
12285                                        break;
12286                                case NEWLINE:
12287                                        {
12288                                        setState(1387);
12289                                        match(NEWLINE);
12290                                        }
12291                                        break;
12292                                case LEADING_ASTERISK:
12293                                        {
12294                                        setState(1388);
12295                                        match(LEADING_ASTERISK);
12296                                        }
12297                                        break;
12298                                case WS:
12299                                        {
12300                                        setState(1389);
12301                                        match(WS);
12302                                        }
12303                                        break;
12304                                default:
12305                                        throw new NoViableAltException(this);
12306                                }
12307                                }
12308                                setState(1394);
12309                                _errHandler.sync(this);
12310                                _la = _input.LA(1);
12311                        }
12312                        setState(1395);
12313                        _la = _input.LA(1);
12314                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12315                        _errHandler.recoverInline(this);
12316                        }
12317                        else {
12318                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12319                                _errHandler.reportMatch(this);
12320                                consume();
12321                        }
12322                        }
12323                }
12324                catch (RecognitionException re) {
12325                        _localctx.exception = re;
12326                        _errHandler.reportError(this, re);
12327                        _errHandler.recover(this, re);
12328                }
12329                finally {
12330                        exitRule();
12331                }
12332                return _localctx;
12333        }
12334
12335        public static class BasefontTagContext extends ParserRuleContext {
12336                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12337                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
12338                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12339                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12340                public List<AttributeContext> attribute() {
12341                        return getRuleContexts(AttributeContext.class);
12342                }
12343                public AttributeContext attribute(int i) {
12344                        return getRuleContext(AttributeContext.class,i);
12345                }
12346                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12347                public TerminalNode NEWLINE(int i) {
12348                        return getToken(JavadocParser.NEWLINE, i);
12349                }
12350                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12351                public TerminalNode LEADING_ASTERISK(int i) {
12352                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12353                }
12354                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12355                public TerminalNode WS(int i) {
12356                        return getToken(JavadocParser.WS, i);
12357                }
12358                public BasefontTagContext(ParserRuleContext parent, int invokingState) {
12359                        super(parent, invokingState);
12360                }
12361                @Override public int getRuleIndex() { return RULE_basefontTag; }
12362                @Override
12363                public void enterRule(ParseTreeListener listener) {
12364                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this);
12365                }
12366                @Override
12367                public void exitRule(ParseTreeListener listener) {
12368                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this);
12369                }
12370                @Override
12371                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12372                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this);
12373                        else return visitor.visitChildren(this);
12374                }
12375        }
12376
12377        public final BasefontTagContext basefontTag() throws RecognitionException {
12378                BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState());
12379                enterRule(_localctx, 110, RULE_basefontTag);
12380                int _la;
12381                try {
12382                        enterOuterAlt(_localctx, 1);
12383                        {
12384                        setState(1397);
12385                        match(OPEN);
12386                        setState(1398);
12387                        match(BASEFONT_HTML_TAG_NAME);
12388                        setState(1405);
12389                        _errHandler.sync(this);
12390                        _la = _input.LA(1);
12391                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12392                                {
12393                                setState(1403);
12394                                _errHandler.sync(this);
12395                                switch (_input.LA(1)) {
12396                                case HTML_TAG_NAME:
12397                                        {
12398                                        setState(1399);
12399                                        attribute();
12400                                        }
12401                                        break;
12402                                case NEWLINE:
12403                                        {
12404                                        setState(1400);
12405                                        match(NEWLINE);
12406                                        }
12407                                        break;
12408                                case LEADING_ASTERISK:
12409                                        {
12410                                        setState(1401);
12411                                        match(LEADING_ASTERISK);
12412                                        }
12413                                        break;
12414                                case WS:
12415                                        {
12416                                        setState(1402);
12417                                        match(WS);
12418                                        }
12419                                        break;
12420                                default:
12421                                        throw new NoViableAltException(this);
12422                                }
12423                                }
12424                                setState(1407);
12425                                _errHandler.sync(this);
12426                                _la = _input.LA(1);
12427                        }
12428                        setState(1408);
12429                        _la = _input.LA(1);
12430                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12431                        _errHandler.recoverInline(this);
12432                        }
12433                        else {
12434                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12435                                _errHandler.reportMatch(this);
12436                                consume();
12437                        }
12438                        }
12439                }
12440                catch (RecognitionException re) {
12441                        _localctx.exception = re;
12442                        _errHandler.reportError(this, re);
12443                        _errHandler.recover(this, re);
12444                }
12445                finally {
12446                        exitRule();
12447                }
12448                return _localctx;
12449        }
12450
12451        public static class BrTagContext extends ParserRuleContext {
12452                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12453                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
12454                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12455                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12456                public List<AttributeContext> attribute() {
12457                        return getRuleContexts(AttributeContext.class);
12458                }
12459                public AttributeContext attribute(int i) {
12460                        return getRuleContext(AttributeContext.class,i);
12461                }
12462                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12463                public TerminalNode NEWLINE(int i) {
12464                        return getToken(JavadocParser.NEWLINE, i);
12465                }
12466                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12467                public TerminalNode LEADING_ASTERISK(int i) {
12468                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12469                }
12470                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12471                public TerminalNode WS(int i) {
12472                        return getToken(JavadocParser.WS, i);
12473                }
12474                public BrTagContext(ParserRuleContext parent, int invokingState) {
12475                        super(parent, invokingState);
12476                }
12477                @Override public int getRuleIndex() { return RULE_brTag; }
12478                @Override
12479                public void enterRule(ParseTreeListener listener) {
12480                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this);
12481                }
12482                @Override
12483                public void exitRule(ParseTreeListener listener) {
12484                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this);
12485                }
12486                @Override
12487                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12488                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this);
12489                        else return visitor.visitChildren(this);
12490                }
12491        }
12492
12493        public final BrTagContext brTag() throws RecognitionException {
12494                BrTagContext _localctx = new BrTagContext(_ctx, getState());
12495                enterRule(_localctx, 112, RULE_brTag);
12496                int _la;
12497                try {
12498                        enterOuterAlt(_localctx, 1);
12499                        {
12500                        setState(1410);
12501                        match(OPEN);
12502                        setState(1411);
12503                        match(BR_HTML_TAG_NAME);
12504                        setState(1418);
12505                        _errHandler.sync(this);
12506                        _la = _input.LA(1);
12507                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12508                                {
12509                                setState(1416);
12510                                _errHandler.sync(this);
12511                                switch (_input.LA(1)) {
12512                                case HTML_TAG_NAME:
12513                                        {
12514                                        setState(1412);
12515                                        attribute();
12516                                        }
12517                                        break;
12518                                case NEWLINE:
12519                                        {
12520                                        setState(1413);
12521                                        match(NEWLINE);
12522                                        }
12523                                        break;
12524                                case LEADING_ASTERISK:
12525                                        {
12526                                        setState(1414);
12527                                        match(LEADING_ASTERISK);
12528                                        }
12529                                        break;
12530                                case WS:
12531                                        {
12532                                        setState(1415);
12533                                        match(WS);
12534                                        }
12535                                        break;
12536                                default:
12537                                        throw new NoViableAltException(this);
12538                                }
12539                                }
12540                                setState(1420);
12541                                _errHandler.sync(this);
12542                                _la = _input.LA(1);
12543                        }
12544                        setState(1421);
12545                        _la = _input.LA(1);
12546                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12547                        _errHandler.recoverInline(this);
12548                        }
12549                        else {
12550                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12551                                _errHandler.reportMatch(this);
12552                                consume();
12553                        }
12554                        }
12555                }
12556                catch (RecognitionException re) {
12557                        _localctx.exception = re;
12558                        _errHandler.reportError(this, re);
12559                        _errHandler.recover(this, re);
12560                }
12561                finally {
12562                        exitRule();
12563                }
12564                return _localctx;
12565        }
12566
12567        public static class ColTagContext extends ParserRuleContext {
12568                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12569                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
12570                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12571                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12572                public List<AttributeContext> attribute() {
12573                        return getRuleContexts(AttributeContext.class);
12574                }
12575                public AttributeContext attribute(int i) {
12576                        return getRuleContext(AttributeContext.class,i);
12577                }
12578                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12579                public TerminalNode NEWLINE(int i) {
12580                        return getToken(JavadocParser.NEWLINE, i);
12581                }
12582                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12583                public TerminalNode LEADING_ASTERISK(int i) {
12584                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12585                }
12586                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12587                public TerminalNode WS(int i) {
12588                        return getToken(JavadocParser.WS, i);
12589                }
12590                public ColTagContext(ParserRuleContext parent, int invokingState) {
12591                        super(parent, invokingState);
12592                }
12593                @Override public int getRuleIndex() { return RULE_colTag; }
12594                @Override
12595                public void enterRule(ParseTreeListener listener) {
12596                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this);
12597                }
12598                @Override
12599                public void exitRule(ParseTreeListener listener) {
12600                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this);
12601                }
12602                @Override
12603                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12604                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this);
12605                        else return visitor.visitChildren(this);
12606                }
12607        }
12608
12609        public final ColTagContext colTag() throws RecognitionException {
12610                ColTagContext _localctx = new ColTagContext(_ctx, getState());
12611                enterRule(_localctx, 114, RULE_colTag);
12612                int _la;
12613                try {
12614                        enterOuterAlt(_localctx, 1);
12615                        {
12616                        setState(1423);
12617                        match(OPEN);
12618                        setState(1424);
12619                        match(COL_HTML_TAG_NAME);
12620                        setState(1431);
12621                        _errHandler.sync(this);
12622                        _la = _input.LA(1);
12623                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12624                                {
12625                                setState(1429);
12626                                _errHandler.sync(this);
12627                                switch (_input.LA(1)) {
12628                                case HTML_TAG_NAME:
12629                                        {
12630                                        setState(1425);
12631                                        attribute();
12632                                        }
12633                                        break;
12634                                case NEWLINE:
12635                                        {
12636                                        setState(1426);
12637                                        match(NEWLINE);
12638                                        }
12639                                        break;
12640                                case LEADING_ASTERISK:
12641                                        {
12642                                        setState(1427);
12643                                        match(LEADING_ASTERISK);
12644                                        }
12645                                        break;
12646                                case WS:
12647                                        {
12648                                        setState(1428);
12649                                        match(WS);
12650                                        }
12651                                        break;
12652                                default:
12653                                        throw new NoViableAltException(this);
12654                                }
12655                                }
12656                                setState(1433);
12657                                _errHandler.sync(this);
12658                                _la = _input.LA(1);
12659                        }
12660                        setState(1434);
12661                        _la = _input.LA(1);
12662                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12663                        _errHandler.recoverInline(this);
12664                        }
12665                        else {
12666                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12667                                _errHandler.reportMatch(this);
12668                                consume();
12669                        }
12670                        }
12671                }
12672                catch (RecognitionException re) {
12673                        _localctx.exception = re;
12674                        _errHandler.reportError(this, re);
12675                        _errHandler.recover(this, re);
12676                }
12677                finally {
12678                        exitRule();
12679                }
12680                return _localctx;
12681        }
12682
12683        public static class FrameTagContext extends ParserRuleContext {
12684                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12685                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
12686                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12687                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12688                public List<AttributeContext> attribute() {
12689                        return getRuleContexts(AttributeContext.class);
12690                }
12691                public AttributeContext attribute(int i) {
12692                        return getRuleContext(AttributeContext.class,i);
12693                }
12694                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12695                public TerminalNode NEWLINE(int i) {
12696                        return getToken(JavadocParser.NEWLINE, i);
12697                }
12698                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12699                public TerminalNode LEADING_ASTERISK(int i) {
12700                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12701                }
12702                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12703                public TerminalNode WS(int i) {
12704                        return getToken(JavadocParser.WS, i);
12705                }
12706                public FrameTagContext(ParserRuleContext parent, int invokingState) {
12707                        super(parent, invokingState);
12708                }
12709                @Override public int getRuleIndex() { return RULE_frameTag; }
12710                @Override
12711                public void enterRule(ParseTreeListener listener) {
12712                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this);
12713                }
12714                @Override
12715                public void exitRule(ParseTreeListener listener) {
12716                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this);
12717                }
12718                @Override
12719                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12720                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this);
12721                        else return visitor.visitChildren(this);
12722                }
12723        }
12724
12725        public final FrameTagContext frameTag() throws RecognitionException {
12726                FrameTagContext _localctx = new FrameTagContext(_ctx, getState());
12727                enterRule(_localctx, 116, RULE_frameTag);
12728                int _la;
12729                try {
12730                        enterOuterAlt(_localctx, 1);
12731                        {
12732                        setState(1436);
12733                        match(OPEN);
12734                        setState(1437);
12735                        match(FRAME_HTML_TAG_NAME);
12736                        setState(1444);
12737                        _errHandler.sync(this);
12738                        _la = _input.LA(1);
12739                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12740                                {
12741                                setState(1442);
12742                                _errHandler.sync(this);
12743                                switch (_input.LA(1)) {
12744                                case HTML_TAG_NAME:
12745                                        {
12746                                        setState(1438);
12747                                        attribute();
12748                                        }
12749                                        break;
12750                                case NEWLINE:
12751                                        {
12752                                        setState(1439);
12753                                        match(NEWLINE);
12754                                        }
12755                                        break;
12756                                case LEADING_ASTERISK:
12757                                        {
12758                                        setState(1440);
12759                                        match(LEADING_ASTERISK);
12760                                        }
12761                                        break;
12762                                case WS:
12763                                        {
12764                                        setState(1441);
12765                                        match(WS);
12766                                        }
12767                                        break;
12768                                default:
12769                                        throw new NoViableAltException(this);
12770                                }
12771                                }
12772                                setState(1446);
12773                                _errHandler.sync(this);
12774                                _la = _input.LA(1);
12775                        }
12776                        setState(1447);
12777                        _la = _input.LA(1);
12778                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12779                        _errHandler.recoverInline(this);
12780                        }
12781                        else {
12782                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12783                                _errHandler.reportMatch(this);
12784                                consume();
12785                        }
12786                        }
12787                }
12788                catch (RecognitionException re) {
12789                        _localctx.exception = re;
12790                        _errHandler.reportError(this, re);
12791                        _errHandler.recover(this, re);
12792                }
12793                finally {
12794                        exitRule();
12795                }
12796                return _localctx;
12797        }
12798
12799        public static class HrTagContext extends ParserRuleContext {
12800                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12801                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
12802                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12803                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12804                public List<AttributeContext> attribute() {
12805                        return getRuleContexts(AttributeContext.class);
12806                }
12807                public AttributeContext attribute(int i) {
12808                        return getRuleContext(AttributeContext.class,i);
12809                }
12810                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12811                public TerminalNode NEWLINE(int i) {
12812                        return getToken(JavadocParser.NEWLINE, i);
12813                }
12814                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12815                public TerminalNode LEADING_ASTERISK(int i) {
12816                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12817                }
12818                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12819                public TerminalNode WS(int i) {
12820                        return getToken(JavadocParser.WS, i);
12821                }
12822                public HrTagContext(ParserRuleContext parent, int invokingState) {
12823                        super(parent, invokingState);
12824                }
12825                @Override public int getRuleIndex() { return RULE_hrTag; }
12826                @Override
12827                public void enterRule(ParseTreeListener listener) {
12828                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this);
12829                }
12830                @Override
12831                public void exitRule(ParseTreeListener listener) {
12832                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this);
12833                }
12834                @Override
12835                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12836                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this);
12837                        else return visitor.visitChildren(this);
12838                }
12839        }
12840
12841        public final HrTagContext hrTag() throws RecognitionException {
12842                HrTagContext _localctx = new HrTagContext(_ctx, getState());
12843                enterRule(_localctx, 118, RULE_hrTag);
12844                int _la;
12845                try {
12846                        enterOuterAlt(_localctx, 1);
12847                        {
12848                        setState(1449);
12849                        match(OPEN);
12850                        setState(1450);
12851                        match(HR_HTML_TAG_NAME);
12852                        setState(1457);
12853                        _errHandler.sync(this);
12854                        _la = _input.LA(1);
12855                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12856                                {
12857                                setState(1455);
12858                                _errHandler.sync(this);
12859                                switch (_input.LA(1)) {
12860                                case HTML_TAG_NAME:
12861                                        {
12862                                        setState(1451);
12863                                        attribute();
12864                                        }
12865                                        break;
12866                                case NEWLINE:
12867                                        {
12868                                        setState(1452);
12869                                        match(NEWLINE);
12870                                        }
12871                                        break;
12872                                case LEADING_ASTERISK:
12873                                        {
12874                                        setState(1453);
12875                                        match(LEADING_ASTERISK);
12876                                        }
12877                                        break;
12878                                case WS:
12879                                        {
12880                                        setState(1454);
12881                                        match(WS);
12882                                        }
12883                                        break;
12884                                default:
12885                                        throw new NoViableAltException(this);
12886                                }
12887                                }
12888                                setState(1459);
12889                                _errHandler.sync(this);
12890                                _la = _input.LA(1);
12891                        }
12892                        setState(1460);
12893                        _la = _input.LA(1);
12894                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12895                        _errHandler.recoverInline(this);
12896                        }
12897                        else {
12898                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
12899                                _errHandler.reportMatch(this);
12900                                consume();
12901                        }
12902                        }
12903                }
12904                catch (RecognitionException re) {
12905                        _localctx.exception = re;
12906                        _errHandler.reportError(this, re);
12907                        _errHandler.recover(this, re);
12908                }
12909                finally {
12910                        exitRule();
12911                }
12912                return _localctx;
12913        }
12914
12915        public static class ImgTagContext extends ParserRuleContext {
12916                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12917                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
12918                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12919                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12920                public List<AttributeContext> attribute() {
12921                        return getRuleContexts(AttributeContext.class);
12922                }
12923                public AttributeContext attribute(int i) {
12924                        return getRuleContext(AttributeContext.class,i);
12925                }
12926                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12927                public TerminalNode NEWLINE(int i) {
12928                        return getToken(JavadocParser.NEWLINE, i);
12929                }
12930                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12931                public TerminalNode LEADING_ASTERISK(int i) {
12932                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12933                }
12934                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12935                public TerminalNode WS(int i) {
12936                        return getToken(JavadocParser.WS, i);
12937                }
12938                public ImgTagContext(ParserRuleContext parent, int invokingState) {
12939                        super(parent, invokingState);
12940                }
12941                @Override public int getRuleIndex() { return RULE_imgTag; }
12942                @Override
12943                public void enterRule(ParseTreeListener listener) {
12944                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this);
12945                }
12946                @Override
12947                public void exitRule(ParseTreeListener listener) {
12948                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this);
12949                }
12950                @Override
12951                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12952                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this);
12953                        else return visitor.visitChildren(this);
12954                }
12955        }
12956
12957        public final ImgTagContext imgTag() throws RecognitionException {
12958                ImgTagContext _localctx = new ImgTagContext(_ctx, getState());
12959                enterRule(_localctx, 120, RULE_imgTag);
12960                int _la;
12961                try {
12962                        enterOuterAlt(_localctx, 1);
12963                        {
12964                        setState(1462);
12965                        match(OPEN);
12966                        setState(1463);
12967                        match(IMG_HTML_TAG_NAME);
12968                        setState(1470);
12969                        _errHandler.sync(this);
12970                        _la = _input.LA(1);
12971                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12972                                {
12973                                setState(1468);
12974                                _errHandler.sync(this);
12975                                switch (_input.LA(1)) {
12976                                case HTML_TAG_NAME:
12977                                        {
12978                                        setState(1464);
12979                                        attribute();
12980                                        }
12981                                        break;
12982                                case NEWLINE:
12983                                        {
12984                                        setState(1465);
12985                                        match(NEWLINE);
12986                                        }
12987                                        break;
12988                                case LEADING_ASTERISK:
12989                                        {
12990                                        setState(1466);
12991                                        match(LEADING_ASTERISK);
12992                                        }
12993                                        break;
12994                                case WS:
12995                                        {
12996                                        setState(1467);
12997                                        match(WS);
12998                                        }
12999                                        break;
13000                                default:
13001                                        throw new NoViableAltException(this);
13002                                }
13003                                }
13004                                setState(1472);
13005                                _errHandler.sync(this);
13006                                _la = _input.LA(1);
13007                        }
13008                        setState(1473);
13009                        _la = _input.LA(1);
13010                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13011                        _errHandler.recoverInline(this);
13012                        }
13013                        else {
13014                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13015                                _errHandler.reportMatch(this);
13016                                consume();
13017                        }
13018                        }
13019                }
13020                catch (RecognitionException re) {
13021                        _localctx.exception = re;
13022                        _errHandler.reportError(this, re);
13023                        _errHandler.recover(this, re);
13024                }
13025                finally {
13026                        exitRule();
13027                }
13028                return _localctx;
13029        }
13030
13031        public static class InputTagContext extends ParserRuleContext {
13032                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13033                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13034                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13035                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13036                public List<AttributeContext> attribute() {
13037                        return getRuleContexts(AttributeContext.class);
13038                }
13039                public AttributeContext attribute(int i) {
13040                        return getRuleContext(AttributeContext.class,i);
13041                }
13042                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13043                public TerminalNode NEWLINE(int i) {
13044                        return getToken(JavadocParser.NEWLINE, i);
13045                }
13046                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13047                public TerminalNode LEADING_ASTERISK(int i) {
13048                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13049                }
13050                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13051                public TerminalNode WS(int i) {
13052                        return getToken(JavadocParser.WS, i);
13053                }
13054                public InputTagContext(ParserRuleContext parent, int invokingState) {
13055                        super(parent, invokingState);
13056                }
13057                @Override public int getRuleIndex() { return RULE_inputTag; }
13058                @Override
13059                public void enterRule(ParseTreeListener listener) {
13060                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this);
13061                }
13062                @Override
13063                public void exitRule(ParseTreeListener listener) {
13064                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this);
13065                }
13066                @Override
13067                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13068                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this);
13069                        else return visitor.visitChildren(this);
13070                }
13071        }
13072
13073        public final InputTagContext inputTag() throws RecognitionException {
13074                InputTagContext _localctx = new InputTagContext(_ctx, getState());
13075                enterRule(_localctx, 122, RULE_inputTag);
13076                int _la;
13077                try {
13078                        enterOuterAlt(_localctx, 1);
13079                        {
13080                        setState(1475);
13081                        match(OPEN);
13082                        setState(1476);
13083                        match(INPUT_HTML_TAG_NAME);
13084                        setState(1483);
13085                        _errHandler.sync(this);
13086                        _la = _input.LA(1);
13087                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13088                                {
13089                                setState(1481);
13090                                _errHandler.sync(this);
13091                                switch (_input.LA(1)) {
13092                                case HTML_TAG_NAME:
13093                                        {
13094                                        setState(1477);
13095                                        attribute();
13096                                        }
13097                                        break;
13098                                case NEWLINE:
13099                                        {
13100                                        setState(1478);
13101                                        match(NEWLINE);
13102                                        }
13103                                        break;
13104                                case LEADING_ASTERISK:
13105                                        {
13106                                        setState(1479);
13107                                        match(LEADING_ASTERISK);
13108                                        }
13109                                        break;
13110                                case WS:
13111                                        {
13112                                        setState(1480);
13113                                        match(WS);
13114                                        }
13115                                        break;
13116                                default:
13117                                        throw new NoViableAltException(this);
13118                                }
13119                                }
13120                                setState(1485);
13121                                _errHandler.sync(this);
13122                                _la = _input.LA(1);
13123                        }
13124                        setState(1486);
13125                        _la = _input.LA(1);
13126                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13127                        _errHandler.recoverInline(this);
13128                        }
13129                        else {
13130                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13131                                _errHandler.reportMatch(this);
13132                                consume();
13133                        }
13134                        }
13135                }
13136                catch (RecognitionException re) {
13137                        _localctx.exception = re;
13138                        _errHandler.reportError(this, re);
13139                        _errHandler.recover(this, re);
13140                }
13141                finally {
13142                        exitRule();
13143                }
13144                return _localctx;
13145        }
13146
13147        public static class IsindexTagContext extends ParserRuleContext {
13148                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13149                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13150                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13151                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13152                public List<AttributeContext> attribute() {
13153                        return getRuleContexts(AttributeContext.class);
13154                }
13155                public AttributeContext attribute(int i) {
13156                        return getRuleContext(AttributeContext.class,i);
13157                }
13158                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13159                public TerminalNode NEWLINE(int i) {
13160                        return getToken(JavadocParser.NEWLINE, i);
13161                }
13162                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13163                public TerminalNode LEADING_ASTERISK(int i) {
13164                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13165                }
13166                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13167                public TerminalNode WS(int i) {
13168                        return getToken(JavadocParser.WS, i);
13169                }
13170                public IsindexTagContext(ParserRuleContext parent, int invokingState) {
13171                        super(parent, invokingState);
13172                }
13173                @Override public int getRuleIndex() { return RULE_isindexTag; }
13174                @Override
13175                public void enterRule(ParseTreeListener listener) {
13176                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this);
13177                }
13178                @Override
13179                public void exitRule(ParseTreeListener listener) {
13180                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this);
13181                }
13182                @Override
13183                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13184                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this);
13185                        else return visitor.visitChildren(this);
13186                }
13187        }
13188
13189        public final IsindexTagContext isindexTag() throws RecognitionException {
13190                IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState());
13191                enterRule(_localctx, 124, RULE_isindexTag);
13192                int _la;
13193                try {
13194                        enterOuterAlt(_localctx, 1);
13195                        {
13196                        setState(1488);
13197                        match(OPEN);
13198                        setState(1489);
13199                        match(ISINDEX_HTML_TAG_NAME);
13200                        setState(1496);
13201                        _errHandler.sync(this);
13202                        _la = _input.LA(1);
13203                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13204                                {
13205                                setState(1494);
13206                                _errHandler.sync(this);
13207                                switch (_input.LA(1)) {
13208                                case HTML_TAG_NAME:
13209                                        {
13210                                        setState(1490);
13211                                        attribute();
13212                                        }
13213                                        break;
13214                                case NEWLINE:
13215                                        {
13216                                        setState(1491);
13217                                        match(NEWLINE);
13218                                        }
13219                                        break;
13220                                case LEADING_ASTERISK:
13221                                        {
13222                                        setState(1492);
13223                                        match(LEADING_ASTERISK);
13224                                        }
13225                                        break;
13226                                case WS:
13227                                        {
13228                                        setState(1493);
13229                                        match(WS);
13230                                        }
13231                                        break;
13232                                default:
13233                                        throw new NoViableAltException(this);
13234                                }
13235                                }
13236                                setState(1498);
13237                                _errHandler.sync(this);
13238                                _la = _input.LA(1);
13239                        }
13240                        setState(1499);
13241                        _la = _input.LA(1);
13242                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13243                        _errHandler.recoverInline(this);
13244                        }
13245                        else {
13246                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13247                                _errHandler.reportMatch(this);
13248                                consume();
13249                        }
13250                        }
13251                }
13252                catch (RecognitionException re) {
13253                        _localctx.exception = re;
13254                        _errHandler.reportError(this, re);
13255                        _errHandler.recover(this, re);
13256                }
13257                finally {
13258                        exitRule();
13259                }
13260                return _localctx;
13261        }
13262
13263        public static class LinkTagContext extends ParserRuleContext {
13264                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13265                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13266                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13267                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13268                public List<AttributeContext> attribute() {
13269                        return getRuleContexts(AttributeContext.class);
13270                }
13271                public AttributeContext attribute(int i) {
13272                        return getRuleContext(AttributeContext.class,i);
13273                }
13274                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13275                public TerminalNode NEWLINE(int i) {
13276                        return getToken(JavadocParser.NEWLINE, i);
13277                }
13278                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13279                public TerminalNode LEADING_ASTERISK(int i) {
13280                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13281                }
13282                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13283                public TerminalNode WS(int i) {
13284                        return getToken(JavadocParser.WS, i);
13285                }
13286                public LinkTagContext(ParserRuleContext parent, int invokingState) {
13287                        super(parent, invokingState);
13288                }
13289                @Override public int getRuleIndex() { return RULE_linkTag; }
13290                @Override
13291                public void enterRule(ParseTreeListener listener) {
13292                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this);
13293                }
13294                @Override
13295                public void exitRule(ParseTreeListener listener) {
13296                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this);
13297                }
13298                @Override
13299                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13300                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this);
13301                        else return visitor.visitChildren(this);
13302                }
13303        }
13304
13305        public final LinkTagContext linkTag() throws RecognitionException {
13306                LinkTagContext _localctx = new LinkTagContext(_ctx, getState());
13307                enterRule(_localctx, 126, RULE_linkTag);
13308                int _la;
13309                try {
13310                        enterOuterAlt(_localctx, 1);
13311                        {
13312                        setState(1501);
13313                        match(OPEN);
13314                        setState(1502);
13315                        match(LINK_HTML_TAG_NAME);
13316                        setState(1509);
13317                        _errHandler.sync(this);
13318                        _la = _input.LA(1);
13319                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13320                                {
13321                                setState(1507);
13322                                _errHandler.sync(this);
13323                                switch (_input.LA(1)) {
13324                                case HTML_TAG_NAME:
13325                                        {
13326                                        setState(1503);
13327                                        attribute();
13328                                        }
13329                                        break;
13330                                case NEWLINE:
13331                                        {
13332                                        setState(1504);
13333                                        match(NEWLINE);
13334                                        }
13335                                        break;
13336                                case LEADING_ASTERISK:
13337                                        {
13338                                        setState(1505);
13339                                        match(LEADING_ASTERISK);
13340                                        }
13341                                        break;
13342                                case WS:
13343                                        {
13344                                        setState(1506);
13345                                        match(WS);
13346                                        }
13347                                        break;
13348                                default:
13349                                        throw new NoViableAltException(this);
13350                                }
13351                                }
13352                                setState(1511);
13353                                _errHandler.sync(this);
13354                                _la = _input.LA(1);
13355                        }
13356                        setState(1512);
13357                        _la = _input.LA(1);
13358                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13359                        _errHandler.recoverInline(this);
13360                        }
13361                        else {
13362                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13363                                _errHandler.reportMatch(this);
13364                                consume();
13365                        }
13366                        }
13367                }
13368                catch (RecognitionException re) {
13369                        _localctx.exception = re;
13370                        _errHandler.reportError(this, re);
13371                        _errHandler.recover(this, re);
13372                }
13373                finally {
13374                        exitRule();
13375                }
13376                return _localctx;
13377        }
13378
13379        public static class MetaTagContext extends ParserRuleContext {
13380                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13381                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13382                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13383                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13384                public List<AttributeContext> attribute() {
13385                        return getRuleContexts(AttributeContext.class);
13386                }
13387                public AttributeContext attribute(int i) {
13388                        return getRuleContext(AttributeContext.class,i);
13389                }
13390                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13391                public TerminalNode NEWLINE(int i) {
13392                        return getToken(JavadocParser.NEWLINE, i);
13393                }
13394                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13395                public TerminalNode LEADING_ASTERISK(int i) {
13396                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13397                }
13398                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13399                public TerminalNode WS(int i) {
13400                        return getToken(JavadocParser.WS, i);
13401                }
13402                public MetaTagContext(ParserRuleContext parent, int invokingState) {
13403                        super(parent, invokingState);
13404                }
13405                @Override public int getRuleIndex() { return RULE_metaTag; }
13406                @Override
13407                public void enterRule(ParseTreeListener listener) {
13408                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this);
13409                }
13410                @Override
13411                public void exitRule(ParseTreeListener listener) {
13412                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this);
13413                }
13414                @Override
13415                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13416                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this);
13417                        else return visitor.visitChildren(this);
13418                }
13419        }
13420
13421        public final MetaTagContext metaTag() throws RecognitionException {
13422                MetaTagContext _localctx = new MetaTagContext(_ctx, getState());
13423                enterRule(_localctx, 128, RULE_metaTag);
13424                int _la;
13425                try {
13426                        enterOuterAlt(_localctx, 1);
13427                        {
13428                        setState(1514);
13429                        match(OPEN);
13430                        setState(1515);
13431                        match(META_HTML_TAG_NAME);
13432                        setState(1522);
13433                        _errHandler.sync(this);
13434                        _la = _input.LA(1);
13435                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13436                                {
13437                                setState(1520);
13438                                _errHandler.sync(this);
13439                                switch (_input.LA(1)) {
13440                                case HTML_TAG_NAME:
13441                                        {
13442                                        setState(1516);
13443                                        attribute();
13444                                        }
13445                                        break;
13446                                case NEWLINE:
13447                                        {
13448                                        setState(1517);
13449                                        match(NEWLINE);
13450                                        }
13451                                        break;
13452                                case LEADING_ASTERISK:
13453                                        {
13454                                        setState(1518);
13455                                        match(LEADING_ASTERISK);
13456                                        }
13457                                        break;
13458                                case WS:
13459                                        {
13460                                        setState(1519);
13461                                        match(WS);
13462                                        }
13463                                        break;
13464                                default:
13465                                        throw new NoViableAltException(this);
13466                                }
13467                                }
13468                                setState(1524);
13469                                _errHandler.sync(this);
13470                                _la = _input.LA(1);
13471                        }
13472                        setState(1525);
13473                        _la = _input.LA(1);
13474                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13475                        _errHandler.recoverInline(this);
13476                        }
13477                        else {
13478                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13479                                _errHandler.reportMatch(this);
13480                                consume();
13481                        }
13482                        }
13483                }
13484                catch (RecognitionException re) {
13485                        _localctx.exception = re;
13486                        _errHandler.reportError(this, re);
13487                        _errHandler.recover(this, re);
13488                }
13489                finally {
13490                        exitRule();
13491                }
13492                return _localctx;
13493        }
13494
13495        public static class ParamTagContext extends ParserRuleContext {
13496                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13497                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13498                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13499                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13500                public List<AttributeContext> attribute() {
13501                        return getRuleContexts(AttributeContext.class);
13502                }
13503                public AttributeContext attribute(int i) {
13504                        return getRuleContext(AttributeContext.class,i);
13505                }
13506                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13507                public TerminalNode NEWLINE(int i) {
13508                        return getToken(JavadocParser.NEWLINE, i);
13509                }
13510                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13511                public TerminalNode LEADING_ASTERISK(int i) {
13512                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13513                }
13514                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13515                public TerminalNode WS(int i) {
13516                        return getToken(JavadocParser.WS, i);
13517                }
13518                public ParamTagContext(ParserRuleContext parent, int invokingState) {
13519                        super(parent, invokingState);
13520                }
13521                @Override public int getRuleIndex() { return RULE_paramTag; }
13522                @Override
13523                public void enterRule(ParseTreeListener listener) {
13524                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this);
13525                }
13526                @Override
13527                public void exitRule(ParseTreeListener listener) {
13528                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this);
13529                }
13530                @Override
13531                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13532                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this);
13533                        else return visitor.visitChildren(this);
13534                }
13535        }
13536
13537        public final ParamTagContext paramTag() throws RecognitionException {
13538                ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
13539                enterRule(_localctx, 130, RULE_paramTag);
13540                int _la;
13541                try {
13542                        enterOuterAlt(_localctx, 1);
13543                        {
13544                        setState(1527);
13545                        match(OPEN);
13546                        setState(1528);
13547                        match(PARAM_HTML_TAG_NAME);
13548                        setState(1535);
13549                        _errHandler.sync(this);
13550                        _la = _input.LA(1);
13551                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13552                                {
13553                                setState(1533);
13554                                _errHandler.sync(this);
13555                                switch (_input.LA(1)) {
13556                                case HTML_TAG_NAME:
13557                                        {
13558                                        setState(1529);
13559                                        attribute();
13560                                        }
13561                                        break;
13562                                case NEWLINE:
13563                                        {
13564                                        setState(1530);
13565                                        match(NEWLINE);
13566                                        }
13567                                        break;
13568                                case LEADING_ASTERISK:
13569                                        {
13570                                        setState(1531);
13571                                        match(LEADING_ASTERISK);
13572                                        }
13573                                        break;
13574                                case WS:
13575                                        {
13576                                        setState(1532);
13577                                        match(WS);
13578                                        }
13579                                        break;
13580                                default:
13581                                        throw new NoViableAltException(this);
13582                                }
13583                                }
13584                                setState(1537);
13585                                _errHandler.sync(this);
13586                                _la = _input.LA(1);
13587                        }
13588                        setState(1538);
13589                        _la = _input.LA(1);
13590                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13591                        _errHandler.recoverInline(this);
13592                        }
13593                        else {
13594                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13595                                _errHandler.reportMatch(this);
13596                                consume();
13597                        }
13598                        }
13599                }
13600                catch (RecognitionException re) {
13601                        _localctx.exception = re;
13602                        _errHandler.reportError(this, re);
13603                        _errHandler.recover(this, re);
13604                }
13605                finally {
13606                        exitRule();
13607                }
13608                return _localctx;
13609        }
13610
13611        public static class WrongSinletonTagContext extends ParserRuleContext {
13612                public SingletonTagNameContext singletonTagName;
13613                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13614                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
13615                public SingletonTagNameContext singletonTagName() {
13616                        return getRuleContext(SingletonTagNameContext.class,0);
13617                }
13618                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13619                public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) {
13620                        super(parent, invokingState);
13621                }
13622                @Override public int getRuleIndex() { return RULE_wrongSinletonTag; }
13623                @Override
13624                public void enterRule(ParseTreeListener listener) {
13625                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this);
13626                }
13627                @Override
13628                public void exitRule(ParseTreeListener listener) {
13629                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this);
13630                }
13631                @Override
13632                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13633                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this);
13634                        else return visitor.visitChildren(this);
13635                }
13636        }
13637
13638        public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException {
13639                WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState());
13640                enterRule(_localctx, 132, RULE_wrongSinletonTag);
13641                try {
13642                        enterOuterAlt(_localctx, 1);
13643                        {
13644                        setState(1540);
13645                        match(OPEN);
13646                        setState(1541);
13647                        match(SLASH);
13648                        setState(1542);
13649                        ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName();
13650                        setState(1543);
13651                        match(CLOSE);
13652                        notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null),
13653                                                     "javadoc.wrong.singleton.html.tag", null);
13654                        }
13655                }
13656                catch (RecognitionException re) {
13657                        _localctx.exception = re;
13658                        _errHandler.reportError(this, re);
13659                        _errHandler.recover(this, re);
13660                }
13661                finally {
13662                        exitRule();
13663                }
13664                return _localctx;
13665        }
13666
13667        public static class SingletonTagNameContext extends ParserRuleContext {
13668                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
13669                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
13670                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
13671                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
13672                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
13673                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
13674                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
13675                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
13676                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13677                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13678                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13679                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13680                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13681                public SingletonTagNameContext(ParserRuleContext parent, int invokingState) {
13682                        super(parent, invokingState);
13683                }
13684                @Override public int getRuleIndex() { return RULE_singletonTagName; }
13685                @Override
13686                public void enterRule(ParseTreeListener listener) {
13687                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this);
13688                }
13689                @Override
13690                public void exitRule(ParseTreeListener listener) {
13691                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this);
13692                }
13693                @Override
13694                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13695                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this);
13696                        else return visitor.visitChildren(this);
13697                }
13698        }
13699
13700        public final SingletonTagNameContext singletonTagName() throws RecognitionException {
13701                SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState());
13702                enterRule(_localctx, 134, RULE_singletonTagName);
13703                int _la;
13704                try {
13705                        enterOuterAlt(_localctx, 1);
13706                        {
13707                        setState(1546);
13708                        _la = _input.LA(1);
13709                        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)) ) {
13710                        _errHandler.recoverInline(this);
13711                        }
13712                        else {
13713                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13714                                _errHandler.reportMatch(this);
13715                                consume();
13716                        }
13717                        }
13718                }
13719                catch (RecognitionException re) {
13720                        _localctx.exception = re;
13721                        _errHandler.reportError(this, re);
13722                        _errHandler.recover(this, re);
13723                }
13724                finally {
13725                        exitRule();
13726                }
13727                return _localctx;
13728        }
13729
13730        public static class DescriptionContext extends ParserRuleContext {
13731                public List<HtmlCommentContext> htmlComment() {
13732                        return getRuleContexts(HtmlCommentContext.class);
13733                }
13734                public HtmlCommentContext htmlComment(int i) {
13735                        return getRuleContext(HtmlCommentContext.class,i);
13736                }
13737                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
13738                public TerminalNode CDATA(int i) {
13739                        return getToken(JavadocParser.CDATA, i);
13740                }
13741                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13742                public TerminalNode NEWLINE(int i) {
13743                        return getToken(JavadocParser.NEWLINE, i);
13744                }
13745                public List<TextContext> text() {
13746                        return getRuleContexts(TextContext.class);
13747                }
13748                public TextContext text(int i) {
13749                        return getRuleContext(TextContext.class,i);
13750                }
13751                public List<JavadocInlineTagContext> javadocInlineTag() {
13752                        return getRuleContexts(JavadocInlineTagContext.class);
13753                }
13754                public JavadocInlineTagContext javadocInlineTag(int i) {
13755                        return getRuleContext(JavadocInlineTagContext.class,i);
13756                }
13757                public List<HtmlElementContext> htmlElement() {
13758                        return getRuleContexts(HtmlElementContext.class);
13759                }
13760                public HtmlElementContext htmlElement(int i) {
13761                        return getRuleContext(HtmlElementContext.class,i);
13762                }
13763                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13764                public TerminalNode LEADING_ASTERISK(int i) {
13765                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13766                }
13767                public DescriptionContext(ParserRuleContext parent, int invokingState) {
13768                        super(parent, invokingState);
13769                }
13770                @Override public int getRuleIndex() { return RULE_description; }
13771                @Override
13772                public void enterRule(ParseTreeListener listener) {
13773                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
13774                }
13775                @Override
13776                public void exitRule(ParseTreeListener listener) {
13777                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
13778                }
13779                @Override
13780                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13781                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
13782                        else return visitor.visitChildren(this);
13783                }
13784        }
13785
13786        public final DescriptionContext description() throws RecognitionException {
13787                DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
13788                enterRule(_localctx, 136, RULE_description);
13789                try {
13790                        int _alt;
13791                        enterOuterAlt(_localctx, 1);
13792                        {
13793                        setState(1556); 
13794                        _errHandler.sync(this);
13795                        _alt = 1;
13796                        do {
13797                                switch (_alt) {
13798                                case 1:
13799                                        {
13800                                        setState(1556);
13801                                        _errHandler.sync(this);
13802                                        switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
13803                                        case 1:
13804                                                {
13805                                                {
13806                                                setState(1548);
13807                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
13808                                                setState(1549);
13809                                                match(LEADING_ASTERISK);
13810                                                }
13811                                                }
13812                                                break;
13813                                        case 2:
13814                                                {
13815                                                setState(1550);
13816                                                htmlComment();
13817                                                }
13818                                                break;
13819                                        case 3:
13820                                                {
13821                                                setState(1551);
13822                                                match(CDATA);
13823                                                }
13824                                                break;
13825                                        case 4:
13826                                                {
13827                                                setState(1552);
13828                                                match(NEWLINE);
13829                                                }
13830                                                break;
13831                                        case 5:
13832                                                {
13833                                                setState(1553);
13834                                                text();
13835                                                }
13836                                                break;
13837                                        case 6:
13838                                                {
13839                                                setState(1554);
13840                                                javadocInlineTag();
13841                                                }
13842                                                break;
13843                                        case 7:
13844                                                {
13845                                                setState(1555);
13846                                                htmlElement();
13847                                                }
13848                                                break;
13849                                        }
13850                                        }
13851                                        break;
13852                                default:
13853                                        throw new NoViableAltException(this);
13854                                }
13855                                setState(1558); 
13856                                _errHandler.sync(this);
13857                                _alt = getInterpreter().adaptivePredict(_input,122,_ctx);
13858                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13859                        }
13860                }
13861                catch (RecognitionException re) {
13862                        _localctx.exception = re;
13863                        _errHandler.reportError(this, re);
13864                        _errHandler.recover(this, re);
13865                }
13866                finally {
13867                        exitRule();
13868                }
13869                return _localctx;
13870        }
13871
13872        public static class ReferenceContext extends ParserRuleContext {
13873                public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); }
13874                public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); }
13875                public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); }
13876                public ParametersContext parameters() {
13877                        return getRuleContext(ParametersContext.class,0);
13878                }
13879                public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); }
13880                public TerminalNode DOT(int i) {
13881                        return getToken(JavadocParser.DOT, i);
13882                }
13883                public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); }
13884                public TerminalNode CLASS(int i) {
13885                        return getToken(JavadocParser.CLASS, i);
13886                }
13887                public ReferenceContext(ParserRuleContext parent, int invokingState) {
13888                        super(parent, invokingState);
13889                }
13890                @Override public int getRuleIndex() { return RULE_reference; }
13891                @Override
13892                public void enterRule(ParseTreeListener listener) {
13893                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this);
13894                }
13895                @Override
13896                public void exitRule(ParseTreeListener listener) {
13897                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this);
13898                }
13899                @Override
13900                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13901                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this);
13902                        else return visitor.visitChildren(this);
13903                }
13904        }
13905
13906        public final ReferenceContext reference() throws RecognitionException {
13907                ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
13908                enterRule(_localctx, 138, RULE_reference);
13909                int _la;
13910                try {
13911                        int _alt;
13912                        enterOuterAlt(_localctx, 1);
13913                        {
13914                        setState(1597);
13915                        _errHandler.sync(this);
13916                        switch (_input.LA(1)) {
13917                        case PACKAGE:
13918                                {
13919                                setState(1560);
13920                                match(PACKAGE);
13921                                setState(1564);
13922                                _errHandler.sync(this);
13923                                _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13924                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13925                                        if ( _alt==1 ) {
13926                                                {
13927                                                {
13928                                                setState(1561);
13929                                                _la = _input.LA(1);
13930                                                if ( !(_la==DOT || _la==CLASS) ) {
13931                                                _errHandler.recoverInline(this);
13932                                                }
13933                                                else {
13934                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13935                                                        _errHandler.reportMatch(this);
13936                                                        consume();
13937                                                }
13938                                                }
13939                                                } 
13940                                        }
13941                                        setState(1566);
13942                                        _errHandler.sync(this);
13943                                        _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13944                                }
13945                                setState(1568);
13946                                _errHandler.sync(this);
13947                                switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
13948                                case 1:
13949                                        {
13950                                        setState(1567);
13951                                        match(HASH);
13952                                        }
13953                                        break;
13954                                }
13955                                setState(1571);
13956                                _errHandler.sync(this);
13957                                switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
13958                                case 1:
13959                                        {
13960                                        setState(1570);
13961                                        match(MEMBER);
13962                                        }
13963                                        break;
13964                                }
13965                                setState(1574);
13966                                _errHandler.sync(this);
13967                                switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
13968                                case 1:
13969                                        {
13970                                        setState(1573);
13971                                        parameters();
13972                                        }
13973                                        break;
13974                                }
13975                                }
13976                                break;
13977                        case DOT:
13978                        case CLASS:
13979                                {
13980                                setState(1577); 
13981                                _errHandler.sync(this);
13982                                _alt = 1;
13983                                do {
13984                                        switch (_alt) {
13985                                        case 1:
13986                                                {
13987                                                {
13988                                                setState(1576);
13989                                                _la = _input.LA(1);
13990                                                if ( !(_la==DOT || _la==CLASS) ) {
13991                                                _errHandler.recoverInline(this);
13992                                                }
13993                                                else {
13994                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
13995                                                        _errHandler.reportMatch(this);
13996                                                        consume();
13997                                                }
13998                                                }
13999                                                }
14000                                                break;
14001                                        default:
14002                                                throw new NoViableAltException(this);
14003                                        }
14004                                        setState(1579); 
14005                                        _errHandler.sync(this);
14006                                        _alt = getInterpreter().adaptivePredict(_input,127,_ctx);
14007                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
14008                                setState(1582);
14009                                _errHandler.sync(this);
14010                                switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
14011                                case 1:
14012                                        {
14013                                        setState(1581);
14014                                        match(HASH);
14015                                        }
14016                                        break;
14017                                }
14018                                setState(1585);
14019                                _errHandler.sync(this);
14020                                switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
14021                                case 1:
14022                                        {
14023                                        setState(1584);
14024                                        match(MEMBER);
14025                                        }
14026                                        break;
14027                                }
14028                                setState(1588);
14029                                _errHandler.sync(this);
14030                                switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
14031                                case 1:
14032                                        {
14033                                        setState(1587);
14034                                        parameters();
14035                                        }
14036                                        break;
14037                                }
14038                                }
14039                                break;
14040                        case HASH:
14041                        case MEMBER:
14042                                {
14043                                setState(1591);
14044                                _errHandler.sync(this);
14045                                _la = _input.LA(1);
14046                                if (_la==HASH) {
14047                                        {
14048                                        setState(1590);
14049                                        match(HASH);
14050                                        }
14051                                }
14052
14053                                setState(1593);
14054                                match(MEMBER);
14055                                setState(1595);
14056                                _errHandler.sync(this);
14057                                switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
14058                                case 1:
14059                                        {
14060                                        setState(1594);
14061                                        parameters();
14062                                        }
14063                                        break;
14064                                }
14065                                }
14066                                break;
14067                        default:
14068                                throw new NoViableAltException(this);
14069                        }
14070                        }
14071                }
14072                catch (RecognitionException re) {
14073                        _localctx.exception = re;
14074                        _errHandler.reportError(this, re);
14075                        _errHandler.recover(this, re);
14076                }
14077                finally {
14078                        exitRule();
14079                }
14080                return _localctx;
14081        }
14082
14083        public static class ParametersContext extends ParserRuleContext {
14084                public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); }
14085                public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); }
14086                public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); }
14087                public TerminalNode ARGUMENT(int i) {
14088                        return getToken(JavadocParser.ARGUMENT, i);
14089                }
14090                public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); }
14091                public TerminalNode COMMA(int i) {
14092                        return getToken(JavadocParser.COMMA, i);
14093                }
14094                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14095                public TerminalNode WS(int i) {
14096                        return getToken(JavadocParser.WS, i);
14097                }
14098                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14099                public TerminalNode NEWLINE(int i) {
14100                        return getToken(JavadocParser.NEWLINE, i);
14101                }
14102                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14103                public TerminalNode LEADING_ASTERISK(int i) {
14104                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14105                }
14106                public ParametersContext(ParserRuleContext parent, int invokingState) {
14107                        super(parent, invokingState);
14108                }
14109                @Override public int getRuleIndex() { return RULE_parameters; }
14110                @Override
14111                public void enterRule(ParseTreeListener listener) {
14112                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this);
14113                }
14114                @Override
14115                public void exitRule(ParseTreeListener listener) {
14116                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this);
14117                }
14118                @Override
14119                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14120                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this);
14121                        else return visitor.visitChildren(this);
14122                }
14123        }
14124
14125        public final ParametersContext parameters() throws RecognitionException {
14126                ParametersContext _localctx = new ParametersContext(_ctx, getState());
14127                enterRule(_localctx, 140, RULE_parameters);
14128                int _la;
14129                try {
14130                        enterOuterAlt(_localctx, 1);
14131                        {
14132                        setState(1599);
14133                        match(LEFT_BRACE);
14134                        setState(1603);
14135                        _errHandler.sync(this);
14136                        _la = _input.LA(1);
14137                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) {
14138                                {
14139                                {
14140                                setState(1600);
14141                                _la = _input.LA(1);
14142                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) {
14143                                _errHandler.recoverInline(this);
14144                                }
14145                                else {
14146                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14147                                        _errHandler.reportMatch(this);
14148                                        consume();
14149                                }
14150                                }
14151                                }
14152                                setState(1605);
14153                                _errHandler.sync(this);
14154                                _la = _input.LA(1);
14155                        }
14156                        setState(1606);
14157                        match(RIGHT_BRACE);
14158                        }
14159                }
14160                catch (RecognitionException re) {
14161                        _localctx.exception = re;
14162                        _errHandler.reportError(this, re);
14163                        _errHandler.recover(this, re);
14164                }
14165                finally {
14166                        exitRule();
14167                }
14168                return _localctx;
14169        }
14170
14171        public static class JavadocTagContext extends ParserRuleContext {
14172                public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); }
14173                public DescriptionContext description() {
14174                        return getRuleContext(DescriptionContext.class,0);
14175                }
14176                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14177                public TerminalNode WS(int i) {
14178                        return getToken(JavadocParser.WS, i);
14179                }
14180                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14181                public TerminalNode NEWLINE(int i) {
14182                        return getToken(JavadocParser.NEWLINE, i);
14183                }
14184                public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); }
14185                public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); }
14186                public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); }
14187                public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); }
14188                public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); }
14189                public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); }
14190                public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); }
14191                public ReferenceContext reference() {
14192                        return getRuleContext(ReferenceContext.class,0);
14193                }
14194                public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); }
14195                public TerminalNode STRING(int i) {
14196                        return getToken(JavadocParser.STRING, i);
14197                }
14198                public List<HtmlElementContext> htmlElement() {
14199                        return getRuleContexts(HtmlElementContext.class);
14200                }
14201                public HtmlElementContext htmlElement(int i) {
14202                        return getRuleContext(HtmlElementContext.class,i);
14203                }
14204                public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); }
14205                public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); }
14206                public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); }
14207                public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); }
14208                public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); }
14209                public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); }
14210                public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); }
14211                public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); }
14212                public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); }
14213                public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); }
14214                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14215                public JavadocTagContext(ParserRuleContext parent, int invokingState) {
14216                        super(parent, invokingState);
14217                }
14218                @Override public int getRuleIndex() { return RULE_javadocTag; }
14219                @Override
14220                public void enterRule(ParseTreeListener listener) {
14221                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this);
14222                }
14223                @Override
14224                public void exitRule(ParseTreeListener listener) {
14225                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this);
14226                }
14227                @Override
14228                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14229                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this);
14230                        else return visitor.visitChildren(this);
14231                }
14232        }
14233
14234        public final JavadocTagContext javadocTag() throws RecognitionException {
14235                JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState());
14236                enterRule(_localctx, 142, RULE_javadocTag);
14237                int _la;
14238                try {
14239                        int _alt;
14240                        setState(1802);
14241                        _errHandler.sync(this);
14242                        switch (_input.LA(1)) {
14243                        case AUTHOR_LITERAL:
14244                                enterOuterAlt(_localctx, 1);
14245                                {
14246                                setState(1608);
14247                                match(AUTHOR_LITERAL);
14248                                setState(1612);
14249                                _errHandler.sync(this);
14250                                _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14251                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14252                                        if ( _alt==1 ) {
14253                                                {
14254                                                {
14255                                                setState(1609);
14256                                                _la = _input.LA(1);
14257                                                if ( !(_la==WS || _la==NEWLINE) ) {
14258                                                _errHandler.recoverInline(this);
14259                                                }
14260                                                else {
14261                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14262                                                        _errHandler.reportMatch(this);
14263                                                        consume();
14264                                                }
14265                                                }
14266                                                } 
14267                                        }
14268                                        setState(1614);
14269                                        _errHandler.sync(this);
14270                                        _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14271                                }
14272                                setState(1616);
14273                                _errHandler.sync(this);
14274                                switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
14275                                case 1:
14276                                        {
14277                                        setState(1615);
14278                                        description();
14279                                        }
14280                                        break;
14281                                }
14282                                }
14283                                break;
14284                        case DEPRECATED_LITERAL:
14285                                enterOuterAlt(_localctx, 2);
14286                                {
14287                                setState(1618);
14288                                match(DEPRECATED_LITERAL);
14289                                setState(1622);
14290                                _errHandler.sync(this);
14291                                _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14292                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14293                                        if ( _alt==1 ) {
14294                                                {
14295                                                {
14296                                                setState(1619);
14297                                                _la = _input.LA(1);
14298                                                if ( !(_la==WS || _la==NEWLINE) ) {
14299                                                _errHandler.recoverInline(this);
14300                                                }
14301                                                else {
14302                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14303                                                        _errHandler.reportMatch(this);
14304                                                        consume();
14305                                                }
14306                                                }
14307                                                } 
14308                                        }
14309                                        setState(1624);
14310                                        _errHandler.sync(this);
14311                                        _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14312                                }
14313                                setState(1626);
14314                                _errHandler.sync(this);
14315                                switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
14316                                case 1:
14317                                        {
14318                                        setState(1625);
14319                                        description();
14320                                        }
14321                                        break;
14322                                }
14323                                }
14324                                break;
14325                        case EXCEPTION_LITERAL:
14326                                enterOuterAlt(_localctx, 3);
14327                                {
14328                                setState(1628);
14329                                match(EXCEPTION_LITERAL);
14330                                setState(1632);
14331                                _errHandler.sync(this);
14332                                _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14333                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14334                                        if ( _alt==1 ) {
14335                                                {
14336                                                {
14337                                                setState(1629);
14338                                                _la = _input.LA(1);
14339                                                if ( !(_la==WS || _la==NEWLINE) ) {
14340                                                _errHandler.recoverInline(this);
14341                                                }
14342                                                else {
14343                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14344                                                        _errHandler.reportMatch(this);
14345                                                        consume();
14346                                                }
14347                                                }
14348                                                } 
14349                                        }
14350                                        setState(1634);
14351                                        _errHandler.sync(this);
14352                                        _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14353                                }
14354                                setState(1636);
14355                                _errHandler.sync(this);
14356                                switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
14357                                case 1:
14358                                        {
14359                                        setState(1635);
14360                                        match(CLASS_NAME);
14361                                        }
14362                                        break;
14363                                }
14364                                setState(1641);
14365                                _errHandler.sync(this);
14366                                _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14367                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14368                                        if ( _alt==1 ) {
14369                                                {
14370                                                {
14371                                                setState(1638);
14372                                                _la = _input.LA(1);
14373                                                if ( !(_la==WS || _la==NEWLINE) ) {
14374                                                _errHandler.recoverInline(this);
14375                                                }
14376                                                else {
14377                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14378                                                        _errHandler.reportMatch(this);
14379                                                        consume();
14380                                                }
14381                                                }
14382                                                } 
14383                                        }
14384                                        setState(1643);
14385                                        _errHandler.sync(this);
14386                                        _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14387                                }
14388                                setState(1645);
14389                                _errHandler.sync(this);
14390                                switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
14391                                case 1:
14392                                        {
14393                                        setState(1644);
14394                                        description();
14395                                        }
14396                                        break;
14397                                }
14398                                }
14399                                break;
14400                        case PARAM_LITERAL:
14401                                enterOuterAlt(_localctx, 4);
14402                                {
14403                                setState(1647);
14404                                match(PARAM_LITERAL);
14405                                setState(1651);
14406                                _errHandler.sync(this);
14407                                _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14408                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14409                                        if ( _alt==1 ) {
14410                                                {
14411                                                {
14412                                                setState(1648);
14413                                                _la = _input.LA(1);
14414                                                if ( !(_la==WS || _la==NEWLINE) ) {
14415                                                _errHandler.recoverInline(this);
14416                                                }
14417                                                else {
14418                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14419                                                        _errHandler.reportMatch(this);
14420                                                        consume();
14421                                                }
14422                                                }
14423                                                } 
14424                                        }
14425                                        setState(1653);
14426                                        _errHandler.sync(this);
14427                                        _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14428                                }
14429                                setState(1655);
14430                                _errHandler.sync(this);
14431                                switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
14432                                case 1:
14433                                        {
14434                                        setState(1654);
14435                                        match(PARAMETER_NAME);
14436                                        }
14437                                        break;
14438                                }
14439                                setState(1660);
14440                                _errHandler.sync(this);
14441                                _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14442                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14443                                        if ( _alt==1 ) {
14444                                                {
14445                                                {
14446                                                setState(1657);
14447                                                _la = _input.LA(1);
14448                                                if ( !(_la==WS || _la==NEWLINE) ) {
14449                                                _errHandler.recoverInline(this);
14450                                                }
14451                                                else {
14452                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14453                                                        _errHandler.reportMatch(this);
14454                                                        consume();
14455                                                }
14456                                                }
14457                                                } 
14458                                        }
14459                                        setState(1662);
14460                                        _errHandler.sync(this);
14461                                        _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14462                                }
14463                                setState(1664);
14464                                _errHandler.sync(this);
14465                                switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
14466                                case 1:
14467                                        {
14468                                        setState(1663);
14469                                        description();
14470                                        }
14471                                        break;
14472                                }
14473                                }
14474                                break;
14475                        case RETURN_LITERAL:
14476                                enterOuterAlt(_localctx, 5);
14477                                {
14478                                setState(1666);
14479                                match(RETURN_LITERAL);
14480                                setState(1670);
14481                                _errHandler.sync(this);
14482                                _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14483                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14484                                        if ( _alt==1 ) {
14485                                                {
14486                                                {
14487                                                setState(1667);
14488                                                _la = _input.LA(1);
14489                                                if ( !(_la==WS || _la==NEWLINE) ) {
14490                                                _errHandler.recoverInline(this);
14491                                                }
14492                                                else {
14493                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14494                                                        _errHandler.reportMatch(this);
14495                                                        consume();
14496                                                }
14497                                                }
14498                                                } 
14499                                        }
14500                                        setState(1672);
14501                                        _errHandler.sync(this);
14502                                        _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14503                                }
14504                                setState(1674);
14505                                _errHandler.sync(this);
14506                                switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
14507                                case 1:
14508                                        {
14509                                        setState(1673);
14510                                        description();
14511                                        }
14512                                        break;
14513                                }
14514                                }
14515                                break;
14516                        case SEE_LITERAL:
14517                                enterOuterAlt(_localctx, 6);
14518                                {
14519                                setState(1676);
14520                                match(SEE_LITERAL);
14521                                setState(1680);
14522                                _errHandler.sync(this);
14523                                _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14524                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14525                                        if ( _alt==1 ) {
14526                                                {
14527                                                {
14528                                                setState(1677);
14529                                                _la = _input.LA(1);
14530                                                if ( !(_la==WS || _la==NEWLINE) ) {
14531                                                _errHandler.recoverInline(this);
14532                                                }
14533                                                else {
14534                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14535                                                        _errHandler.reportMatch(this);
14536                                                        consume();
14537                                                }
14538                                                }
14539                                                } 
14540                                        }
14541                                        setState(1682);
14542                                        _errHandler.sync(this);
14543                                        _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14544                                }
14545                                setState(1684);
14546                                _errHandler.sync(this);
14547                                switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
14548                                case 1:
14549                                        {
14550                                        setState(1683);
14551                                        reference();
14552                                        }
14553                                        break;
14554                                }
14555                                setState(1690);
14556                                _errHandler.sync(this);
14557                                _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14558                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14559                                        if ( _alt==1 ) {
14560                                                {
14561                                                setState(1688);
14562                                                _errHandler.sync(this);
14563                                                switch (_input.LA(1)) {
14564                                                case STRING:
14565                                                        {
14566                                                        setState(1686);
14567                                                        match(STRING);
14568                                                        }
14569                                                        break;
14570                                                case OPEN:
14571                                                        {
14572                                                        setState(1687);
14573                                                        htmlElement();
14574                                                        }
14575                                                        break;
14576                                                default:
14577                                                        throw new NoViableAltException(this);
14578                                                }
14579                                                } 
14580                                        }
14581                                        setState(1692);
14582                                        _errHandler.sync(this);
14583                                        _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14584                                }
14585                                setState(1696);
14586                                _errHandler.sync(this);
14587                                _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14588                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14589                                        if ( _alt==1 ) {
14590                                                {
14591                                                {
14592                                                setState(1693);
14593                                                _la = _input.LA(1);
14594                                                if ( !(_la==WS || _la==NEWLINE) ) {
14595                                                _errHandler.recoverInline(this);
14596                                                }
14597                                                else {
14598                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14599                                                        _errHandler.reportMatch(this);
14600                                                        consume();
14601                                                }
14602                                                }
14603                                                } 
14604                                        }
14605                                        setState(1698);
14606                                        _errHandler.sync(this);
14607                                        _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14608                                }
14609                                setState(1700);
14610                                _errHandler.sync(this);
14611                                switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
14612                                case 1:
14613                                        {
14614                                        setState(1699);
14615                                        description();
14616                                        }
14617                                        break;
14618                                }
14619                                }
14620                                break;
14621                        case SERIAL_LITERAL:
14622                                enterOuterAlt(_localctx, 7);
14623                                {
14624                                setState(1702);
14625                                match(SERIAL_LITERAL);
14626                                setState(1706);
14627                                _errHandler.sync(this);
14628                                _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14629                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14630                                        if ( _alt==1 ) {
14631                                                {
14632                                                {
14633                                                setState(1703);
14634                                                _la = _input.LA(1);
14635                                                if ( !(_la==WS || _la==NEWLINE) ) {
14636                                                _errHandler.recoverInline(this);
14637                                                }
14638                                                else {
14639                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14640                                                        _errHandler.reportMatch(this);
14641                                                        consume();
14642                                                }
14643                                                }
14644                                                } 
14645                                        }
14646                                        setState(1708);
14647                                        _errHandler.sync(this);
14648                                        _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14649                                }
14650                                setState(1710);
14651                                _errHandler.sync(this);
14652                                switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
14653                                case 1:
14654                                        {
14655                                        setState(1709);
14656                                        _la = _input.LA(1);
14657                                        if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) {
14658                                        _errHandler.recoverInline(this);
14659                                        }
14660                                        else {
14661                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14662                                                _errHandler.reportMatch(this);
14663                                                consume();
14664                                        }
14665                                        }
14666                                        break;
14667                                }
14668                                setState(1713);
14669                                _errHandler.sync(this);
14670                                switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
14671                                case 1:
14672                                        {
14673                                        setState(1712);
14674                                        description();
14675                                        }
14676                                        break;
14677                                }
14678                                }
14679                                break;
14680                        case SERIAL_DATA_LITERAL:
14681                                enterOuterAlt(_localctx, 8);
14682                                {
14683                                setState(1715);
14684                                match(SERIAL_DATA_LITERAL);
14685                                setState(1719);
14686                                _errHandler.sync(this);
14687                                _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14688                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14689                                        if ( _alt==1 ) {
14690                                                {
14691                                                {
14692                                                setState(1716);
14693                                                _la = _input.LA(1);
14694                                                if ( !(_la==WS || _la==NEWLINE) ) {
14695                                                _errHandler.recoverInline(this);
14696                                                }
14697                                                else {
14698                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14699                                                        _errHandler.reportMatch(this);
14700                                                        consume();
14701                                                }
14702                                                }
14703                                                } 
14704                                        }
14705                                        setState(1721);
14706                                        _errHandler.sync(this);
14707                                        _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14708                                }
14709                                setState(1723);
14710                                _errHandler.sync(this);
14711                                switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
14712                                case 1:
14713                                        {
14714                                        setState(1722);
14715                                        description();
14716                                        }
14717                                        break;
14718                                }
14719                                }
14720                                break;
14721                        case SERIAL_FIELD_LITERAL:
14722                                enterOuterAlt(_localctx, 9);
14723                                {
14724                                setState(1725);
14725                                match(SERIAL_FIELD_LITERAL);
14726                                setState(1729);
14727                                _errHandler.sync(this);
14728                                _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14729                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14730                                        if ( _alt==1 ) {
14731                                                {
14732                                                {
14733                                                setState(1726);
14734                                                _la = _input.LA(1);
14735                                                if ( !(_la==WS || _la==NEWLINE) ) {
14736                                                _errHandler.recoverInline(this);
14737                                                }
14738                                                else {
14739                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14740                                                        _errHandler.reportMatch(this);
14741                                                        consume();
14742                                                }
14743                                                }
14744                                                } 
14745                                        }
14746                                        setState(1731);
14747                                        _errHandler.sync(this);
14748                                        _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14749                                }
14750                                setState(1733);
14751                                _errHandler.sync(this);
14752                                switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
14753                                case 1:
14754                                        {
14755                                        setState(1732);
14756                                        match(FIELD_NAME);
14757                                        }
14758                                        break;
14759                                }
14760                                setState(1738);
14761                                _errHandler.sync(this);
14762                                _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14763                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14764                                        if ( _alt==1 ) {
14765                                                {
14766                                                {
14767                                                setState(1735);
14768                                                _la = _input.LA(1);
14769                                                if ( !(_la==WS || _la==NEWLINE) ) {
14770                                                _errHandler.recoverInline(this);
14771                                                }
14772                                                else {
14773                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14774                                                        _errHandler.reportMatch(this);
14775                                                        consume();
14776                                                }
14777                                                }
14778                                                } 
14779                                        }
14780                                        setState(1740);
14781                                        _errHandler.sync(this);
14782                                        _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14783                                }
14784                                setState(1742);
14785                                _errHandler.sync(this);
14786                                switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
14787                                case 1:
14788                                        {
14789                                        setState(1741);
14790                                        match(FIELD_TYPE);
14791                                        }
14792                                        break;
14793                                }
14794                                setState(1747);
14795                                _errHandler.sync(this);
14796                                _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14797                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14798                                        if ( _alt==1 ) {
14799                                                {
14800                                                {
14801                                                setState(1744);
14802                                                _la = _input.LA(1);
14803                                                if ( !(_la==WS || _la==NEWLINE) ) {
14804                                                _errHandler.recoverInline(this);
14805                                                }
14806                                                else {
14807                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14808                                                        _errHandler.reportMatch(this);
14809                                                        consume();
14810                                                }
14811                                                }
14812                                                } 
14813                                        }
14814                                        setState(1749);
14815                                        _errHandler.sync(this);
14816                                        _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14817                                }
14818                                setState(1751);
14819                                _errHandler.sync(this);
14820                                switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
14821                                case 1:
14822                                        {
14823                                        setState(1750);
14824                                        description();
14825                                        }
14826                                        break;
14827                                }
14828                                }
14829                                break;
14830                        case SINCE_LITERAL:
14831                                enterOuterAlt(_localctx, 10);
14832                                {
14833                                setState(1753);
14834                                match(SINCE_LITERAL);
14835                                setState(1757);
14836                                _errHandler.sync(this);
14837                                _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14838                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14839                                        if ( _alt==1 ) {
14840                                                {
14841                                                {
14842                                                setState(1754);
14843                                                _la = _input.LA(1);
14844                                                if ( !(_la==WS || _la==NEWLINE) ) {
14845                                                _errHandler.recoverInline(this);
14846                                                }
14847                                                else {
14848                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14849                                                        _errHandler.reportMatch(this);
14850                                                        consume();
14851                                                }
14852                                                }
14853                                                } 
14854                                        }
14855                                        setState(1759);
14856                                        _errHandler.sync(this);
14857                                        _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14858                                }
14859                                setState(1761);
14860                                _errHandler.sync(this);
14861                                switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
14862                                case 1:
14863                                        {
14864                                        setState(1760);
14865                                        description();
14866                                        }
14867                                        break;
14868                                }
14869                                }
14870                                break;
14871                        case THROWS_LITERAL:
14872                                enterOuterAlt(_localctx, 11);
14873                                {
14874                                setState(1763);
14875                                match(THROWS_LITERAL);
14876                                setState(1767);
14877                                _errHandler.sync(this);
14878                                _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14879                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14880                                        if ( _alt==1 ) {
14881                                                {
14882                                                {
14883                                                setState(1764);
14884                                                _la = _input.LA(1);
14885                                                if ( !(_la==WS || _la==NEWLINE) ) {
14886                                                _errHandler.recoverInline(this);
14887                                                }
14888                                                else {
14889                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14890                                                        _errHandler.reportMatch(this);
14891                                                        consume();
14892                                                }
14893                                                }
14894                                                } 
14895                                        }
14896                                        setState(1769);
14897                                        _errHandler.sync(this);
14898                                        _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14899                                }
14900                                setState(1771);
14901                                _errHandler.sync(this);
14902                                switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
14903                                case 1:
14904                                        {
14905                                        setState(1770);
14906                                        match(CLASS_NAME);
14907                                        }
14908                                        break;
14909                                }
14910                                setState(1776);
14911                                _errHandler.sync(this);
14912                                _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14913                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14914                                        if ( _alt==1 ) {
14915                                                {
14916                                                {
14917                                                setState(1773);
14918                                                _la = _input.LA(1);
14919                                                if ( !(_la==WS || _la==NEWLINE) ) {
14920                                                _errHandler.recoverInline(this);
14921                                                }
14922                                                else {
14923                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14924                                                        _errHandler.reportMatch(this);
14925                                                        consume();
14926                                                }
14927                                                }
14928                                                } 
14929                                        }
14930                                        setState(1778);
14931                                        _errHandler.sync(this);
14932                                        _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14933                                }
14934                                setState(1780);
14935                                _errHandler.sync(this);
14936                                switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
14937                                case 1:
14938                                        {
14939                                        setState(1779);
14940                                        description();
14941                                        }
14942                                        break;
14943                                }
14944                                }
14945                                break;
14946                        case VERSION_LITERAL:
14947                                enterOuterAlt(_localctx, 12);
14948                                {
14949                                setState(1782);
14950                                match(VERSION_LITERAL);
14951                                setState(1786);
14952                                _errHandler.sync(this);
14953                                _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14954                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14955                                        if ( _alt==1 ) {
14956                                                {
14957                                                {
14958                                                setState(1783);
14959                                                _la = _input.LA(1);
14960                                                if ( !(_la==WS || _la==NEWLINE) ) {
14961                                                _errHandler.recoverInline(this);
14962                                                }
14963                                                else {
14964                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
14965                                                        _errHandler.reportMatch(this);
14966                                                        consume();
14967                                                }
14968                                                }
14969                                                } 
14970                                        }
14971                                        setState(1788);
14972                                        _errHandler.sync(this);
14973                                        _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14974                                }
14975                                setState(1790);
14976                                _errHandler.sync(this);
14977                                switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
14978                                case 1:
14979                                        {
14980                                        setState(1789);
14981                                        description();
14982                                        }
14983                                        break;
14984                                }
14985                                }
14986                                break;
14987                        case CUSTOM_NAME:
14988                                enterOuterAlt(_localctx, 13);
14989                                {
14990                                setState(1792);
14991                                match(CUSTOM_NAME);
14992                                setState(1796);
14993                                _errHandler.sync(this);
14994                                _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14995                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14996                                        if ( _alt==1 ) {
14997                                                {
14998                                                {
14999                                                setState(1793);
15000                                                _la = _input.LA(1);
15001                                                if ( !(_la==WS || _la==NEWLINE) ) {
15002                                                _errHandler.recoverInline(this);
15003                                                }
15004                                                else {
15005                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15006                                                        _errHandler.reportMatch(this);
15007                                                        consume();
15008                                                }
15009                                                }
15010                                                } 
15011                                        }
15012                                        setState(1798);
15013                                        _errHandler.sync(this);
15014                                        _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
15015                                }
15016                                setState(1800);
15017                                _errHandler.sync(this);
15018                                switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
15019                                case 1:
15020                                        {
15021                                        setState(1799);
15022                                        description();
15023                                        }
15024                                        break;
15025                                }
15026                                }
15027                                break;
15028                        default:
15029                                throw new NoViableAltException(this);
15030                        }
15031                }
15032                catch (RecognitionException re) {
15033                        _localctx.exception = re;
15034                        _errHandler.reportError(this, re);
15035                        _errHandler.recover(this, re);
15036                }
15037                finally {
15038                        exitRule();
15039                }
15040                return _localctx;
15041        }
15042
15043        public static class JavadocInlineTagContext extends ParserRuleContext {
15044                public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); }
15045                public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); }
15046                public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); }
15047                public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); }
15048                public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); }
15049                public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); }
15050                public ReferenceContext reference() {
15051                        return getRuleContext(ReferenceContext.class,0);
15052                }
15053                public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); }
15054                public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); }
15055                public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); }
15056                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
15057                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15058                public TerminalNode WS(int i) {
15059                        return getToken(JavadocParser.WS, i);
15060                }
15061                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15062                public TerminalNode NEWLINE(int i) {
15063                        return getToken(JavadocParser.NEWLINE, i);
15064                }
15065                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15066                public TerminalNode LEADING_ASTERISK(int i) {
15067                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15068                }
15069                public List<TextContext> text() {
15070                        return getRuleContexts(TextContext.class);
15071                }
15072                public TextContext text(int i) {
15073                        return getRuleContext(TextContext.class,i);
15074                }
15075                public DescriptionContext description() {
15076                        return getRuleContext(DescriptionContext.class,0);
15077                }
15078                public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) {
15079                        super(parent, invokingState);
15080                }
15081                @Override public int getRuleIndex() { return RULE_javadocInlineTag; }
15082                @Override
15083                public void enterRule(ParseTreeListener listener) {
15084                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this);
15085                }
15086                @Override
15087                public void exitRule(ParseTreeListener listener) {
15088                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this);
15089                }
15090                @Override
15091                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15092                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this);
15093                        else return visitor.visitChildren(this);
15094                }
15095        }
15096
15097        public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException {
15098                JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState());
15099                enterRule(_localctx, 144, RULE_javadocInlineTag);
15100                int _la;
15101                try {
15102                        int _alt;
15103                        enterOuterAlt(_localctx, 1);
15104                        {
15105                        setState(1804);
15106                        match(JAVADOC_INLINE_TAG_START);
15107                        setState(1881);
15108                        _errHandler.sync(this);
15109                        switch (_input.LA(1)) {
15110                        case CODE_LITERAL:
15111                                {
15112                                setState(1805);
15113                                match(CODE_LITERAL);
15114                                setState(1812);
15115                                _errHandler.sync(this);
15116                                _la = _input.LA(1);
15117                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15118                                        {
15119                                        setState(1810);
15120                                        _errHandler.sync(this);
15121                                        switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
15122                                        case 1:
15123                                                {
15124                                                setState(1806);
15125                                                match(WS);
15126                                                }
15127                                                break;
15128                                        case 2:
15129                                                {
15130                                                setState(1807);
15131                                                match(NEWLINE);
15132                                                }
15133                                                break;
15134                                        case 3:
15135                                                {
15136                                                setState(1808);
15137                                                match(LEADING_ASTERISK);
15138                                                }
15139                                                break;
15140                                        case 4:
15141                                                {
15142                                                setState(1809);
15143                                                text();
15144                                                }
15145                                                break;
15146                                        }
15147                                        }
15148                                        setState(1814);
15149                                        _errHandler.sync(this);
15150                                        _la = _input.LA(1);
15151                                }
15152                                }
15153                                break;
15154                        case DOC_ROOT_LITERAL:
15155                                {
15156                                setState(1815);
15157                                match(DOC_ROOT_LITERAL);
15158                                setState(1819);
15159                                _errHandler.sync(this);
15160                                _la = _input.LA(1);
15161                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15162                                        {
15163                                        {
15164                                        setState(1816);
15165                                        _la = _input.LA(1);
15166                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15167                                        _errHandler.recoverInline(this);
15168                                        }
15169                                        else {
15170                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15171                                                _errHandler.reportMatch(this);
15172                                                consume();
15173                                        }
15174                                        }
15175                                        }
15176                                        setState(1821);
15177                                        _errHandler.sync(this);
15178                                        _la = _input.LA(1);
15179                                }
15180                                }
15181                                break;
15182                        case INHERIT_DOC_LITERAL:
15183                                {
15184                                setState(1822);
15185                                match(INHERIT_DOC_LITERAL);
15186                                setState(1826);
15187                                _errHandler.sync(this);
15188                                _la = _input.LA(1);
15189                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15190                                        {
15191                                        {
15192                                        setState(1823);
15193                                        _la = _input.LA(1);
15194                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15195                                        _errHandler.recoverInline(this);
15196                                        }
15197                                        else {
15198                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15199                                                _errHandler.reportMatch(this);
15200                                                consume();
15201                                        }
15202                                        }
15203                                        }
15204                                        setState(1828);
15205                                        _errHandler.sync(this);
15206                                        _la = _input.LA(1);
15207                                }
15208                                }
15209                                break;
15210                        case LINK_LITERAL:
15211                                {
15212                                setState(1829);
15213                                match(LINK_LITERAL);
15214                                setState(1833);
15215                                _errHandler.sync(this);
15216                                _la = _input.LA(1);
15217                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15218                                        {
15219                                        {
15220                                        setState(1830);
15221                                        _la = _input.LA(1);
15222                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15223                                        _errHandler.recoverInline(this);
15224                                        }
15225                                        else {
15226                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15227                                                _errHandler.reportMatch(this);
15228                                                consume();
15229                                        }
15230                                        }
15231                                        }
15232                                        setState(1835);
15233                                        _errHandler.sync(this);
15234                                        _la = _input.LA(1);
15235                                }
15236                                setState(1836);
15237                                reference();
15238                                setState(1838);
15239                                _errHandler.sync(this);
15240                                switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
15241                                case 1:
15242                                        {
15243                                        setState(1837);
15244                                        description();
15245                                        }
15246                                        break;
15247                                }
15248                                }
15249                                break;
15250                        case LINKPLAIN_LITERAL:
15251                                {
15252                                setState(1840);
15253                                match(LINKPLAIN_LITERAL);
15254                                setState(1844);
15255                                _errHandler.sync(this);
15256                                _la = _input.LA(1);
15257                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15258                                        {
15259                                        {
15260                                        setState(1841);
15261                                        _la = _input.LA(1);
15262                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15263                                        _errHandler.recoverInline(this);
15264                                        }
15265                                        else {
15266                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15267                                                _errHandler.reportMatch(this);
15268                                                consume();
15269                                        }
15270                                        }
15271                                        }
15272                                        setState(1846);
15273                                        _errHandler.sync(this);
15274                                        _la = _input.LA(1);
15275                                }
15276                                setState(1847);
15277                                reference();
15278                                setState(1849);
15279                                _errHandler.sync(this);
15280                                switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
15281                                case 1:
15282                                        {
15283                                        setState(1848);
15284                                        description();
15285                                        }
15286                                        break;
15287                                }
15288                                }
15289                                break;
15290                        case LITERAL_LITERAL:
15291                                {
15292                                setState(1851);
15293                                match(LITERAL_LITERAL);
15294                                setState(1858);
15295                                _errHandler.sync(this);
15296                                _la = _input.LA(1);
15297                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15298                                        {
15299                                        setState(1856);
15300                                        _errHandler.sync(this);
15301                                        switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
15302                                        case 1:
15303                                                {
15304                                                setState(1852);
15305                                                match(WS);
15306                                                }
15307                                                break;
15308                                        case 2:
15309                                                {
15310                                                setState(1853);
15311                                                match(NEWLINE);
15312                                                }
15313                                                break;
15314                                        case 3:
15315                                                {
15316                                                setState(1854);
15317                                                match(LEADING_ASTERISK);
15318                                                }
15319                                                break;
15320                                        case 4:
15321                                                {
15322                                                setState(1855);
15323                                                text();
15324                                                }
15325                                                break;
15326                                        }
15327                                        }
15328                                        setState(1860);
15329                                        _errHandler.sync(this);
15330                                        _la = _input.LA(1);
15331                                }
15332                                }
15333                                break;
15334                        case VALUE_LITERAL:
15335                                {
15336                                setState(1861);
15337                                match(VALUE_LITERAL);
15338                                setState(1865);
15339                                _errHandler.sync(this);
15340                                _la = _input.LA(1);
15341                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15342                                        {
15343                                        {
15344                                        setState(1862);
15345                                        _la = _input.LA(1);
15346                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15347                                        _errHandler.recoverInline(this);
15348                                        }
15349                                        else {
15350                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15351                                                _errHandler.reportMatch(this);
15352                                                consume();
15353                                        }
15354                                        }
15355                                        }
15356                                        setState(1867);
15357                                        _errHandler.sync(this);
15358                                        _la = _input.LA(1);
15359                                }
15360                                setState(1869);
15361                                _errHandler.sync(this);
15362                                _la = _input.LA(1);
15363                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) {
15364                                        {
15365                                        setState(1868);
15366                                        reference();
15367                                        }
15368                                }
15369
15370                                }
15371                                break;
15372                        case CUSTOM_NAME:
15373                                {
15374                                setState(1871);
15375                                match(CUSTOM_NAME);
15376                                setState(1875);
15377                                _errHandler.sync(this);
15378                                _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15379                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
15380                                        if ( _alt==1 ) {
15381                                                {
15382                                                {
15383                                                setState(1872);
15384                                                _la = _input.LA(1);
15385                                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15386                                                _errHandler.recoverInline(this);
15387                                                }
15388                                                else {
15389                                                        if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15390                                                        _errHandler.reportMatch(this);
15391                                                        consume();
15392                                                }
15393                                                }
15394                                                } 
15395                                        }
15396                                        setState(1877);
15397                                        _errHandler.sync(this);
15398                                        _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15399                                }
15400                                setState(1879);
15401                                _errHandler.sync(this);
15402                                switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
15403                                case 1:
15404                                        {
15405                                        setState(1878);
15406                                        description();
15407                                        }
15408                                        break;
15409                                }
15410                                }
15411                                break;
15412                        default:
15413                                throw new NoViableAltException(this);
15414                        }
15415                        setState(1883);
15416                        match(JAVADOC_INLINE_TAG_END);
15417                        }
15418                }
15419                catch (RecognitionException re) {
15420                        _localctx.exception = re;
15421                        _errHandler.reportError(this, re);
15422                        _errHandler.recover(this, re);
15423                }
15424                finally {
15425                        exitRule();
15426                }
15427                return _localctx;
15428        }
15429
15430        public static class HtmlCommentContext extends ParserRuleContext {
15431                public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); }
15432                public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); }
15433                public List<TextContext> text() {
15434                        return getRuleContexts(TextContext.class);
15435                }
15436                public TextContext text(int i) {
15437                        return getRuleContext(TextContext.class,i);
15438                }
15439                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15440                public TerminalNode NEWLINE(int i) {
15441                        return getToken(JavadocParser.NEWLINE, i);
15442                }
15443                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15444                public TerminalNode LEADING_ASTERISK(int i) {
15445                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15446                }
15447                public HtmlCommentContext(ParserRuleContext parent, int invokingState) {
15448                        super(parent, invokingState);
15449                }
15450                @Override public int getRuleIndex() { return RULE_htmlComment; }
15451                @Override
15452                public void enterRule(ParseTreeListener listener) {
15453                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this);
15454                }
15455                @Override
15456                public void exitRule(ParseTreeListener listener) {
15457                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this);
15458                }
15459                @Override
15460                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15461                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this);
15462                        else return visitor.visitChildren(this);
15463                }
15464        }
15465
15466        public final HtmlCommentContext htmlComment() throws RecognitionException {
15467                HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState());
15468                enterRule(_localctx, 146, RULE_htmlComment);
15469                int _la;
15470                try {
15471                        enterOuterAlt(_localctx, 1);
15472                        {
15473                        setState(1885);
15474                        match(HTML_COMMENT_START);
15475                        setState(1891);
15476                        _errHandler.sync(this);
15477                        _la = _input.LA(1);
15478                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15479                                {
15480                                setState(1889);
15481                                _errHandler.sync(this);
15482                                switch (_input.LA(1)) {
15483                                case WS:
15484                                case CHAR:
15485                                        {
15486                                        setState(1886);
15487                                        text();
15488                                        }
15489                                        break;
15490                                case NEWLINE:
15491                                        {
15492                                        setState(1887);
15493                                        match(NEWLINE);
15494                                        }
15495                                        break;
15496                                case LEADING_ASTERISK:
15497                                        {
15498                                        setState(1888);
15499                                        match(LEADING_ASTERISK);
15500                                        }
15501                                        break;
15502                                default:
15503                                        throw new NoViableAltException(this);
15504                                }
15505                                }
15506                                setState(1893);
15507                                _errHandler.sync(this);
15508                                _la = _input.LA(1);
15509                        }
15510                        setState(1894);
15511                        match(HTML_COMMENT_END);
15512                        }
15513                }
15514                catch (RecognitionException re) {
15515                        _localctx.exception = re;
15516                        _errHandler.reportError(this, re);
15517                        _errHandler.recover(this, re);
15518                }
15519                finally {
15520                        exitRule();
15521                }
15522                return _localctx;
15523        }
15524
15525        public static class TextContext extends ParserRuleContext {
15526                public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); }
15527                public TerminalNode CHAR(int i) {
15528                        return getToken(JavadocParser.CHAR, i);
15529                }
15530                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15531                public TerminalNode WS(int i) {
15532                        return getToken(JavadocParser.WS, i);
15533                }
15534                public TextContext(ParserRuleContext parent, int invokingState) {
15535                        super(parent, invokingState);
15536                }
15537                @Override public int getRuleIndex() { return RULE_text; }
15538                @Override
15539                public void enterRule(ParseTreeListener listener) {
15540                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this);
15541                }
15542                @Override
15543                public void exitRule(ParseTreeListener listener) {
15544                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this);
15545                }
15546                @Override
15547                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15548                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this);
15549                        else return visitor.visitChildren(this);
15550                }
15551        }
15552
15553        public final TextContext text() throws RecognitionException {
15554                TextContext _localctx = new TextContext(_ctx, getState());
15555                enterRule(_localctx, 148, RULE_text);
15556                int _la;
15557                try {
15558                        int _alt;
15559                        enterOuterAlt(_localctx, 1);
15560                        {
15561                        setState(1898); 
15562                        _errHandler.sync(this);
15563                        _alt = 1;
15564                        do {
15565                                switch (_alt) {
15566                                case 1:
15567                                        {
15568                                        {
15569                                        setState(1896);
15570                                        _la = _input.LA(1);
15571                                        if ( !(_la==WS || _la==CHAR) ) {
15572                                        _errHandler.recoverInline(this);
15573                                        }
15574                                        else {
15575                                                if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
15576                                                _errHandler.reportMatch(this);
15577                                                consume();
15578                                        }
15579
15580                                          _la = _input.LA(1);
15581                                          if ((_la != WS) && (_la != CHAR)) return _localctx;
15582                                          else if (_alt == 1) continue;
15583                                         
15584                                        }
15585                                        }
15586                                        break;
15587                                default:
15588                                        throw new NoViableAltException(this);
15589                                }
15590                                setState(1900); 
15591                                _errHandler.sync(this);
15592                                _alt = getInterpreter().adaptivePredict(_input,194,_ctx);
15593                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15594                        }
15595                }
15596                catch (RecognitionException re) {
15597                        _localctx.exception = re;
15598                        _errHandler.reportError(this, re);
15599                        _errHandler.recover(this, re);
15600                }
15601                finally {
15602                        exitRule();
15603                }
15604                return _localctx;
15605        }
15606
15607        public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
15608                switch (ruleIndex) {
15609                case 0:
15610                        return javadoc_sempred((JavadocContext)_localctx, predIndex);
15611                case 5:
15612                        return htmlTag_sempred((HtmlTagContext)_localctx, predIndex);
15613                case 8:
15614                        return paragraph_sempred((ParagraphContext)_localctx, predIndex);
15615                case 11:
15616                        return li_sempred((LiContext)_localctx, predIndex);
15617                case 14:
15618                        return tr_sempred((TrContext)_localctx, predIndex);
15619                case 17:
15620                        return td_sempred((TdContext)_localctx, predIndex);
15621                case 20:
15622                        return th_sempred((ThContext)_localctx, predIndex);
15623                case 23:
15624                        return body_sempred((BodyContext)_localctx, predIndex);
15625                case 26:
15626                        return colgroup_sempred((ColgroupContext)_localctx, predIndex);
15627                case 29:
15628                        return dd_sempred((DdContext)_localctx, predIndex);
15629                case 32:
15630                        return dt_sempred((DtContext)_localctx, predIndex);
15631                case 35:
15632                        return head_sempred((HeadContext)_localctx, predIndex);
15633                case 38:
15634                        return html_sempred((HtmlContext)_localctx, predIndex);
15635                case 41:
15636                        return option_sempred((OptionContext)_localctx, predIndex);
15637                case 44:
15638                        return tbody_sempred((TbodyContext)_localctx, predIndex);
15639                case 47:
15640                        return tfoot_sempred((TfootContext)_localctx, predIndex);
15641                case 50:
15642                        return thead_sempred((TheadContext)_localctx, predIndex);
15643                case 68:
15644                        return description_sempred((DescriptionContext)_localctx, predIndex);
15645                }
15646                return true;
15647        }
15648        private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) {
15649                switch (predIndex) {
15650                case 0:
15651                        return !isNextJavadocTag();
15652                }
15653                return true;
15654        }
15655        private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) {
15656                switch (predIndex) {
15657                case 1:
15658                        return !isNextJavadocTag();
15659                case 2:
15660                        return !isNextJavadocTag();
15661                }
15662                return true;
15663        }
15664        private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) {
15665                switch (predIndex) {
15666                case 3:
15667                        return !isNextJavadocTag();
15668                }
15669                return true;
15670        }
15671        private boolean li_sempred(LiContext _localctx, int predIndex) {
15672                switch (predIndex) {
15673                case 4:
15674                        return !isNextJavadocTag();
15675                }
15676                return true;
15677        }
15678        private boolean tr_sempred(TrContext _localctx, int predIndex) {
15679                switch (predIndex) {
15680                case 5:
15681                        return !isNextJavadocTag();
15682                }
15683                return true;
15684        }
15685        private boolean td_sempred(TdContext _localctx, int predIndex) {
15686                switch (predIndex) {
15687                case 6:
15688                        return !isNextJavadocTag();
15689                }
15690                return true;
15691        }
15692        private boolean th_sempred(ThContext _localctx, int predIndex) {
15693                switch (predIndex) {
15694                case 7:
15695                        return !isNextJavadocTag();
15696                }
15697                return true;
15698        }
15699        private boolean body_sempred(BodyContext _localctx, int predIndex) {
15700                switch (predIndex) {
15701                case 8:
15702                        return !isNextJavadocTag();
15703                }
15704                return true;
15705        }
15706        private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) {
15707                switch (predIndex) {
15708                case 9:
15709                        return !isNextJavadocTag();
15710                }
15711                return true;
15712        }
15713        private boolean dd_sempred(DdContext _localctx, int predIndex) {
15714                switch (predIndex) {
15715                case 10:
15716                        return !isNextJavadocTag();
15717                }
15718                return true;
15719        }
15720        private boolean dt_sempred(DtContext _localctx, int predIndex) {
15721                switch (predIndex) {
15722                case 11:
15723                        return !isNextJavadocTag();
15724                }
15725                return true;
15726        }
15727        private boolean head_sempred(HeadContext _localctx, int predIndex) {
15728                switch (predIndex) {
15729                case 12:
15730                        return !isNextJavadocTag();
15731                }
15732                return true;
15733        }
15734        private boolean html_sempred(HtmlContext _localctx, int predIndex) {
15735                switch (predIndex) {
15736                case 13:
15737                        return !isNextJavadocTag();
15738                }
15739                return true;
15740        }
15741        private boolean option_sempred(OptionContext _localctx, int predIndex) {
15742                switch (predIndex) {
15743                case 14:
15744                        return !isNextJavadocTag();
15745                }
15746                return true;
15747        }
15748        private boolean tbody_sempred(TbodyContext _localctx, int predIndex) {
15749                switch (predIndex) {
15750                case 15:
15751                        return !isNextJavadocTag();
15752                }
15753                return true;
15754        }
15755        private boolean tfoot_sempred(TfootContext _localctx, int predIndex) {
15756                switch (predIndex) {
15757                case 16:
15758                        return !isNextJavadocTag();
15759                }
15760                return true;
15761        }
15762        private boolean thead_sempred(TheadContext _localctx, int predIndex) {
15763                switch (predIndex) {
15764                case 17:
15765                        return !isNextJavadocTag();
15766                }
15767                return true;
15768        }
15769        private boolean description_sempred(DescriptionContext _localctx, int predIndex) {
15770                switch (predIndex) {
15771                case 18:
15772                        return !isNextJavadocTag();
15773                }
15774                return true;
15775        }
15776
15777        public static final String _serializedATN =
15778                "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3]\u0771\4\2\t\2\4"+
15779                "\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"+
15780                "\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"+
15781                "\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"+
15782                "\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!"+
15783                "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
15784                ",\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"+
15785                "\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="+
15786                "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
15787                "\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"+
15788                "\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"+
15789                "\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"+
15790                "\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"+
15791                "\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"+
15792                "\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"+
15793                "\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"+
15794                "\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"+
15795                "\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"+
15796                "\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"+
15797                "\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"+
15798                "\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"+
15799                "\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"+
15800                "\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"+
15801                "\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"+
15802                "\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"+
15803                "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+
15804                "\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"+
15805                "\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"+
15806                "\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"+
15807                "\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"+
15808                "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+
15809                "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+
15810                "\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"+
15811                "\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"+
15812                "\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"+
15813                "\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"+
15814                "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+
15815                "\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"+
15816                "\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"+
15817                "\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"+
15818                "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+
15819                "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+
15820                "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+
15821                "\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"+
15822                "\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"+
15823                "\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"+
15824                "\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"+
15825                "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+
15826                "\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"+
15827                "\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"+
15828                "\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"+
15829                "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+
15830                "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+
15831                "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+
15832                "\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"+
15833                "\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"+
15834                "\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"+
15835                "\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"+
15836                "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+
15837                "\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"+
15838                "\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"+
15839                "\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"+
15840                "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+
15841                " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+
15842                "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
15843                "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
15844                "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+
15845                "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+
15846                "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15847                "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15848                "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+
15849                "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+
15850                "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15851                "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15852                "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+
15853                ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+
15854                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\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+\7+\u046a\n+\f+\16+\u046d\13+"+
15856                "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+
15857                "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15858                "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15859                "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+
15860                "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+
15861                "\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"+
15862                "\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"+
15863                "\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"+
15864                "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+
15865                "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+
15866                "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+
15867                "\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"+
15868                "\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"+
15869                "\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"+
15870                "\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"+
15871                "\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"+
15872                "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+
15873                "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+
15874                "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+
15875                "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+
15876                "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+
15877                "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+
15878                "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+
15879                "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+
15880                "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+
15881                "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+
15882                "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+
15883                "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+
15884                "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+
15885                "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+
15886                "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+
15887                "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+
15888                "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+
15889                "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+
15890                "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+
15891                "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+
15892                "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+
15893                "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+
15894                "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+
15895                "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+
15896                "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+
15897                "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+
15898                "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+
15899                "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+
15900                "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+
15901                "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+
15902                "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+
15903                "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+
15904                "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+
15905                "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+
15906                "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+
15907                "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+
15908                "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+
15909                "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+
15910                "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+
15911                "\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"+
15912                "\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"+
15913                "\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"+
15914                "\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"+
15915                "\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"+
15916                " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+
15917                "\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"+
15918                "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+
15919                "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+
15920                "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+
15921                "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+
15922                "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+
15923                "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+
15924                "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+
15925                "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+
15926                "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+
15927                "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+
15928                "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+
15929                "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+
15930                "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+
15931                "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+
15932                "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+
15933                "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+
15934                "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
15935                "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+
15936                "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+
15937                "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+
15938                "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+
15939                "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
15940                "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+
15941                "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+
15942                "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+
15943                "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+
15944                "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+
15945                "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+
15946                "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+
15947                "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+
15948                "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+
15949                "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+
15950                "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+
15951                "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+
15952                "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+
15953                "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+
15954                "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+
15955                "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+
15956                "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+
15957                "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+
15958                "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+
15959                "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+
15960                "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+
15961                "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+
15962                "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+
15963                "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+
15964                "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+
15965                "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+
15966                "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+
15967                "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+
15968                "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+
15969                "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+
15970                "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+
15971                "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+
15972                "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+
15973                "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+
15974                "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
15975                "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+
15976                "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+
15977                "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+
15978                "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+
15979                "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+
15980                "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+
15981                "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+
15982                "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+
15983                "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+
15984                "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+
15985                "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+
15986                "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+
15987                "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
15988                "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+
15989                "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+
15990                "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+
15991                "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+
15992                "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+
15993                "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+
15994                "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+
15995                "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+
15996                "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+
15997                "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+
15998                "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+
15999                "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
16000                "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+
16001                "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+
16002                "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+
16003                "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+
16004                "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+
16005                "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+
16006                "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+
16007                "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+
16008                "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+
16009                "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+
16010                "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+
16011                "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+
16012                "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+
16013                "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+
16014                "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+
16015                "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+
16016                "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+
16017                "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+
16018                "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+
16019                "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+
16020                "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+
16021                "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+
16022                "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
16023                "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+
16024                "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+
16025                "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+
16026                "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+
16027                "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+
16028                "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+
16029                "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+
16030                "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
16031                "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+
16032                "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+
16033                "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+
16034                "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+
16035                "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+
16036                "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+
16037                "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+
16038                "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+
16039                "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+
16040                "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+
16041                "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+
16042                "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+
16043                "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+
16044                "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+
16045                "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+
16046                "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+
16047                "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+
16048                "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+
16049                "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+
16050                "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+
16051                "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+
16052                "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+
16053                "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+
16054                "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+
16055                "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+
16056                "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+
16057                "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+
16058                "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+
16059                "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+
16060                "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+
16061                "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+
16062                "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+
16063                "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+
16064                "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
16065                "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
16066                "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+
16067                "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+
16068                "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+
16069                "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+
16070                "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+
16071                "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+
16072                "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+
16073                "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+
16074                "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+
16075                "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+
16076                "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+
16077                "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+
16078                "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+
16079                "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+
16080                "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+
16081                "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+
16082                "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+
16083                "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+
16084                "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+
16085                "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+
16086                "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+
16087                "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+
16088                "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+
16089                "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+
16090                "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+
16091                "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+
16092                "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+
16093                "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+
16094                "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+
16095                "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+
16096                "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+
16097                "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+
16098                "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+
16099                "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+
16100                "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+
16101                "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+
16102                "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+
16103                "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+
16104                "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+
16105                "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+
16106                "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+
16107                "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+
16108                "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+
16109                "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+
16110                "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+
16111                "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+
16112                "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+
16113                "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+
16114                "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+
16115                "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+
16116                "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+
16117                "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+
16118                "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+
16119                "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+
16120                "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+
16121                "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+
16122                "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+
16123                "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
16124                "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+
16125                "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+
16126                "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+
16127                "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+
16128                "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+
16129                "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+
16130                "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+
16131                "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+
16132                "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+
16133                "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+
16134                "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+
16135                "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+
16136                "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+
16137                "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+
16138                "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+
16139                "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+
16140                "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+
16141                "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+
16142                "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+
16143                "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+
16144                "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+
16145                "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+
16146                "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+
16147                "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+
16148                "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+
16149                "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
16150                "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+
16151                "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+
16152                "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+
16153                "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+
16154                "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+
16155                "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+
16156                "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+
16157                "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+
16158                "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+
16159                "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+
16160                "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+
16161                "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+
16162                "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+
16163                "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+
16164                "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+
16165                "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+
16166                "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+
16167                ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+
16168                "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+
16169                "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+
16170                "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+
16171                "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+
16172                "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+
16173                "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+
16174                "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+
16175                "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+
16176                "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+
16177                "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+
16178                "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+
16179                "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+
16180                "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+
16181                "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+
16182                "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+
16183                "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+
16184                "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+
16185                "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+
16186                "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+
16187                "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+
16188                "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+
16189                "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+
16190                "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+
16191                "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+
16192                "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+
16193                "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+
16194                "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+
16195                "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+
16196                "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+
16197                "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+
16198                "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+
16199                "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+
16200                "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+
16201                "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+
16202                "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+
16203                "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+
16204                "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+
16205                "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+
16206                "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+
16207                "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+
16208                "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+
16209                "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+
16210                "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+
16211                "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
16212                "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+
16213                "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+
16214                "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+
16215                "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+
16216                "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+
16217                "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+
16218                "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+
16219                "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+
16220                "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+
16221                ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+
16222                "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+
16223                "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+
16224                "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+
16225                "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+
16226                "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+
16227                "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+
16228                "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+
16229                "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+
16230                "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+
16231                "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+
16232                "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+
16233                "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+
16234                "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+
16235                "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+
16236                "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+
16237                "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+
16238                "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+
16239                "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+
16240                "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+
16241                "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+
16242                "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+
16243                "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+
16244                "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+
16245                "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+
16246                "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+
16247                "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
16248                "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+
16249                "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+
16250                "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+
16251                "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+
16252                "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+
16253                "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+
16254                "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+
16255                "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+
16256                "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+
16257                "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+
16258                "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+
16259                "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+
16260                "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+
16261                "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+
16262                "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+
16263                "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+
16264                "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+
16265                "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+
16266                "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+
16267                "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+
16268                "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+
16269                "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+
16270                "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+
16271                "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+
16272                "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+
16273                "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+
16274                "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+
16275                "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+
16276                "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+
16277                "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+
16278                "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+
16279                "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+
16280                "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+
16281                "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+
16282                "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+
16283                "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+
16284                "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+
16285                "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+
16286                "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+
16287                "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+
16288                "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+
16289                "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+
16290                "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+
16291                "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+
16292                "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+
16293                "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+
16294                "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+
16295                "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+
16296                "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+
16297                "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+
16298                "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+
16299                "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+
16300                "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+
16301                "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+
16302                "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+
16303                "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+
16304                "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+
16305                "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+
16306                "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+
16307                "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+
16308                "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
16309                "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+
16310                "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+
16311                "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+
16312                "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+
16313                "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+
16314                "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+
16315                "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+
16316                "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+
16317                "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+
16318                "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+
16319                "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+
16320                "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+
16321                "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+
16322                "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+
16323                "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+
16324                "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+
16325                "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+
16326                "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+
16327                "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+
16328                "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+
16329                "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+
16330                "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+
16331                "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+
16332                "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+
16333                "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+
16334                "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+
16335                "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+
16336                "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+
16337                "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+
16338                "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+
16339                "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+
16340                "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+
16341                "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+
16342                "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+
16343                "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+
16344                "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+
16345                "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+
16346                "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+
16347                "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+
16348                "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+
16349                "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+
16350                "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+
16351                "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+
16352                "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+
16353                "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+
16354                "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+
16355                "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+
16356                "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+
16357                "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+
16358                "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+
16359                "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+
16360                "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+
16361                "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+
16362                "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+
16363                "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+
16364                "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+
16365                "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+
16366                "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+
16367                "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+
16368                "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+
16369                "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+
16370                "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+
16371                "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+
16372                "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+
16373                "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+
16374                "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+
16375                "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+
16376                "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+
16377                "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+
16378                "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+
16379                "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+
16380                "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+
16381                "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+
16382                "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+
16383                "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+
16384                "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+
16385                "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+
16386                "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+
16387                "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+
16388                "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+
16389                "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+
16390                "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+
16391                "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+
16392                "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+
16393                "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+
16394                "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+
16395                "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+
16396                "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+
16397                "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+
16398                "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+
16399                "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+
16400                "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+
16401                "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+
16402                "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+
16403                "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+
16404                "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+
16405                "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+
16406                "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+
16407                "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+
16408                "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+
16409                "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+
16410                "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+
16411                "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+
16412                "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+
16413                "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+
16414                "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+
16415                "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+
16416                "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+
16417                "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+
16418                "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+
16419                "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+
16420                "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+
16421                "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+
16422                "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+
16423                "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+
16424                "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+
16425                "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+
16426                "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+
16427                "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+
16428                "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+
16429                "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+
16430                "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+
16431                "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+
16432                "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+
16433                "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+
16434                "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+
16435                "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+
16436                "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+
16437                "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+
16438                "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+
16439                "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+
16440                "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+
16441                "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+
16442                "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+
16443                "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+
16444                "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+
16445                "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+
16446                "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+
16447                "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+
16448                "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+
16449                "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+
16450                "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+
16451                "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+
16452                "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+
16453                "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+
16454                "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+
16455                "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+
16456                "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+
16457                "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+
16458                "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+
16459                "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
16460                "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+
16461                "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+
16462                "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+
16463                "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+
16464                "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+
16465                "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+
16466                "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+
16467                "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+
16468                "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+
16469                "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+
16470                "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+
16471                "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+
16472                "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+
16473                "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+
16474                "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+
16475                "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+
16476                "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+
16477                "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+
16478                "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+
16479                "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+
16480                "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+
16481                "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+
16482                "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+
16483                "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+
16484                "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+
16485                "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+
16486                "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+
16487                "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+
16488                "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+
16489                "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+
16490                "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+
16491                "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+
16492                "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+
16493                "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+
16494                "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+
16495                "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+
16496                "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+
16497                "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+
16498                "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+
16499                "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+
16500                "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+
16501                "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+
16502                "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+
16503                "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+
16504                "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+
16505                "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+
16506                "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+
16507                "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+
16508                "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+
16509                "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+
16510                "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+
16511                "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+
16512                "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+
16513                "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+
16514                "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+
16515                "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+
16516                "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+
16517                "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+
16518                "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+
16519                "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+
16520                "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+
16521                "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+
16522                "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+
16523                "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+
16524                "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+
16525                "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+
16526                "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+
16527                "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+
16528                "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
16529                "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+
16530                "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+
16531                "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+
16532                "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+
16533                "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+
16534                "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+
16535                "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+
16536                "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+
16537                "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+
16538                "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+
16539                "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+
16540                "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+
16541                "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+
16542                "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+
16543                "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+
16544                "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+
16545                "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+
16546                "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+
16547                "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+
16548                "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+
16549                "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+
16550                "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+
16551                "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+
16552                "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+
16553                "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+
16554                "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+
16555                "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+
16556                "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+
16557                "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+
16558                "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+
16559                "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+
16560                "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+
16561                "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+
16562                "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+
16563                "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+
16564                "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+
16565                "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+
16566                "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+
16567                "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+
16568                "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+
16569                "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+
16570                "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+
16571                "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+
16572                "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+
16573                "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+
16574                "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+
16575                "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+
16576                "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+
16577                "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+
16578                "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+
16579                "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+
16580                "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+
16581                "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+
16582                "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+
16583                "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+
16584                "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+
16585                "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+
16586                "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+
16587                "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+
16588                "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+
16589                "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+
16590                "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+
16591                "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
16592                "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+
16593                "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+
16594                "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+
16595                "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+
16596                "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+
16597                "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+
16598                "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+
16599                "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+
16600                "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+
16601                "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+
16602                "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+
16603                "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+
16604                "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+
16605                "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+
16606                "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+
16607                "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+
16608                "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+
16609                "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+
16610                "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+
16611                "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+
16612                "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+
16613                "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+
16614                "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+
16615                "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+
16616                "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+
16617                "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+
16618                "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+
16619                "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+
16620                "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+
16621                "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+
16622                "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+
16623                "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+
16624                "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+
16625                "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+
16626                "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+
16627                "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+
16628                "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+
16629                "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+
16630                "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+
16631                "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+
16632                "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+
16633                "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+
16634                "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+
16635                "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+
16636                "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+
16637                "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+
16638                "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+
16639                "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+
16640                "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+
16641                "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+
16642                "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+
16643                "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+
16644                "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+
16645                "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+
16646                "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+
16647                "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+
16648                "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+
16649                "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+
16650                "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+
16651                "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+
16652                "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+
16653                "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+
16654                "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
16655                "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+
16656                "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+
16657                "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+
16658                "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+
16659                "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+
16660                "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+
16661                "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+
16662                "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+
16663                "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+
16664                "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+
16665                "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+
16666                "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+
16667                "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+
16668                "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+
16669                "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+
16670                "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+
16671                "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+
16672                "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+
16673                "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+
16674                "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+
16675                "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+
16676                "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+
16677                "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+
16678                "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+
16679                "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+
16680                "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+
16681                "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+
16682                "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+
16683                "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+
16684                "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e";
16685        public static final ATN _ATN =
16686                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
16687        static {
16688                _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
16689                for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
16690                        _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
16691                }
16692        }
16693}