001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.5.1
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.5.1", 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, BASEFRONT_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_basefrontTag = 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", "basefrontTag", "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", "BASEFRONT_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                                        switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
278                                        case 1:
279                                                {
280                                                setState(150);
281                                                htmlElement();
282                                                }
283                                                break;
284                                        case 2:
285                                                {
286                                                {
287                                                setState(151);
288                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
289                                                setState(152);
290                                                match(LEADING_ASTERISK);
291                                                }
292                                                }
293                                                break;
294                                        case 3:
295                                                {
296                                                setState(153);
297                                                htmlComment();
298                                                }
299                                                break;
300                                        case 4:
301                                                {
302                                                setState(154);
303                                                match(CDATA);
304                                                }
305                                                break;
306                                        case 5:
307                                                {
308                                                setState(155);
309                                                match(NEWLINE);
310                                                }
311                                                break;
312                                        case 6:
313                                                {
314                                                setState(156);
315                                                text();
316                                                }
317                                                break;
318                                        case 7:
319                                                {
320                                                setState(157);
321                                                javadocInlineTag();
322                                                }
323                                                break;
324                                        }
325                                        } 
326                                }
327                                setState(162);
328                                _errHandler.sync(this);
329                                _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
330                        }
331                        setState(175);
332                        _errHandler.sync(this);
333                        _la = _input.LA(1);
334                        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)) {
335                                {
336                                {
337                                setState(164);
338                                _la = _input.LA(1);
339                                if (_la==LEADING_ASTERISK) {
340                                        {
341                                        setState(163);
342                                        match(LEADING_ASTERISK);
343                                        }
344                                }
345
346                                setState(169);
347                                _errHandler.sync(this);
348                                _la = _input.LA(1);
349                                while (_la==WS) {
350                                        {
351                                        {
352                                        setState(166);
353                                        match(WS);
354                                        }
355                                        }
356                                        setState(171);
357                                        _errHandler.sync(this);
358                                        _la = _input.LA(1);
359                                }
360                                setState(172);
361                                javadocTag();
362                                }
363                                }
364                                setState(177);
365                                _errHandler.sync(this);
366                                _la = _input.LA(1);
367                        }
368                        setState(178);
369                        match(EOF);
370                        }
371                }
372                catch (RecognitionException re) {
373                        _localctx.exception = re;
374                        _errHandler.reportError(this, re);
375                        _errHandler.recover(this, re);
376                }
377                finally {
378                        exitRule();
379                }
380                return _localctx;
381        }
382
383        public static class HtmlElementContext extends ParserRuleContext {
384                public HtmlTagContext htmlTag() {
385                        return getRuleContext(HtmlTagContext.class,0);
386                }
387                public SingletonElementContext singletonElement() {
388                        return getRuleContext(SingletonElementContext.class,0);
389                }
390                public ParagraphContext paragraph() {
391                        return getRuleContext(ParagraphContext.class,0);
392                }
393                public LiContext li() {
394                        return getRuleContext(LiContext.class,0);
395                }
396                public TrContext tr() {
397                        return getRuleContext(TrContext.class,0);
398                }
399                public TdContext td() {
400                        return getRuleContext(TdContext.class,0);
401                }
402                public ThContext th() {
403                        return getRuleContext(ThContext.class,0);
404                }
405                public BodyContext body() {
406                        return getRuleContext(BodyContext.class,0);
407                }
408                public ColgroupContext colgroup() {
409                        return getRuleContext(ColgroupContext.class,0);
410                }
411                public DdContext dd() {
412                        return getRuleContext(DdContext.class,0);
413                }
414                public DtContext dt() {
415                        return getRuleContext(DtContext.class,0);
416                }
417                public HeadContext head() {
418                        return getRuleContext(HeadContext.class,0);
419                }
420                public HtmlContext html() {
421                        return getRuleContext(HtmlContext.class,0);
422                }
423                public OptionContext option() {
424                        return getRuleContext(OptionContext.class,0);
425                }
426                public TbodyContext tbody() {
427                        return getRuleContext(TbodyContext.class,0);
428                }
429                public TheadContext thead() {
430                        return getRuleContext(TheadContext.class,0);
431                }
432                public TfootContext tfoot() {
433                        return getRuleContext(TfootContext.class,0);
434                }
435                public PTagOpenContext pTagOpen() {
436                        return getRuleContext(PTagOpenContext.class,0);
437                }
438                public LiTagOpenContext liTagOpen() {
439                        return getRuleContext(LiTagOpenContext.class,0);
440                }
441                public TrTagOpenContext trTagOpen() {
442                        return getRuleContext(TrTagOpenContext.class,0);
443                }
444                public TdTagOpenContext tdTagOpen() {
445                        return getRuleContext(TdTagOpenContext.class,0);
446                }
447                public ThTagOpenContext thTagOpen() {
448                        return getRuleContext(ThTagOpenContext.class,0);
449                }
450                public BodyTagOpenContext bodyTagOpen() {
451                        return getRuleContext(BodyTagOpenContext.class,0);
452                }
453                public ColgroupTagOpenContext colgroupTagOpen() {
454                        return getRuleContext(ColgroupTagOpenContext.class,0);
455                }
456                public DdTagOpenContext ddTagOpen() {
457                        return getRuleContext(DdTagOpenContext.class,0);
458                }
459                public DtTagOpenContext dtTagOpen() {
460                        return getRuleContext(DtTagOpenContext.class,0);
461                }
462                public HeadTagOpenContext headTagOpen() {
463                        return getRuleContext(HeadTagOpenContext.class,0);
464                }
465                public HtmlTagOpenContext htmlTagOpen() {
466                        return getRuleContext(HtmlTagOpenContext.class,0);
467                }
468                public OptionTagOpenContext optionTagOpen() {
469                        return getRuleContext(OptionTagOpenContext.class,0);
470                }
471                public TbodyTagOpenContext tbodyTagOpen() {
472                        return getRuleContext(TbodyTagOpenContext.class,0);
473                }
474                public TheadTagOpenContext theadTagOpen() {
475                        return getRuleContext(TheadTagOpenContext.class,0);
476                }
477                public TfootTagOpenContext tfootTagOpen() {
478                        return getRuleContext(TfootTagOpenContext.class,0);
479                }
480                public PTagCloseContext pTagClose() {
481                        return getRuleContext(PTagCloseContext.class,0);
482                }
483                public LiTagCloseContext liTagClose() {
484                        return getRuleContext(LiTagCloseContext.class,0);
485                }
486                public TrTagCloseContext trTagClose() {
487                        return getRuleContext(TrTagCloseContext.class,0);
488                }
489                public TdTagCloseContext tdTagClose() {
490                        return getRuleContext(TdTagCloseContext.class,0);
491                }
492                public ThTagCloseContext thTagClose() {
493                        return getRuleContext(ThTagCloseContext.class,0);
494                }
495                public BodyTagCloseContext bodyTagClose() {
496                        return getRuleContext(BodyTagCloseContext.class,0);
497                }
498                public ColgroupTagCloseContext colgroupTagClose() {
499                        return getRuleContext(ColgroupTagCloseContext.class,0);
500                }
501                public DdTagCloseContext ddTagClose() {
502                        return getRuleContext(DdTagCloseContext.class,0);
503                }
504                public DtTagCloseContext dtTagClose() {
505                        return getRuleContext(DtTagCloseContext.class,0);
506                }
507                public HeadTagCloseContext headTagClose() {
508                        return getRuleContext(HeadTagCloseContext.class,0);
509                }
510                public HtmlTagCloseContext htmlTagClose() {
511                        return getRuleContext(HtmlTagCloseContext.class,0);
512                }
513                public OptionTagCloseContext optionTagClose() {
514                        return getRuleContext(OptionTagCloseContext.class,0);
515                }
516                public TbodyTagCloseContext tbodyTagClose() {
517                        return getRuleContext(TbodyTagCloseContext.class,0);
518                }
519                public TheadTagCloseContext theadTagClose() {
520                        return getRuleContext(TheadTagCloseContext.class,0);
521                }
522                public TfootTagCloseContext tfootTagClose() {
523                        return getRuleContext(TfootTagCloseContext.class,0);
524                }
525                public HtmlElementContext(ParserRuleContext parent, int invokingState) {
526                        super(parent, invokingState);
527                }
528                @Override public int getRuleIndex() { return RULE_htmlElement; }
529                @Override
530                public void enterRule(ParseTreeListener listener) {
531                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this);
532                }
533                @Override
534                public void exitRule(ParseTreeListener listener) {
535                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this);
536                }
537                @Override
538                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
539                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this);
540                        else return visitor.visitChildren(this);
541                }
542        }
543
544        public final HtmlElementContext htmlElement() throws RecognitionException {
545                HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
546                enterRule(_localctx, 2, RULE_htmlElement);
547                try {
548                        setState(227);
549                        switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
550                        case 1:
551                                enterOuterAlt(_localctx, 1);
552                                {
553                                setState(180);
554                                htmlTag();
555                                }
556                                break;
557                        case 2:
558                                enterOuterAlt(_localctx, 2);
559                                {
560                                setState(181);
561                                singletonElement();
562                                }
563                                break;
564                        case 3:
565                                enterOuterAlt(_localctx, 3);
566                                {
567                                setState(182);
568                                paragraph();
569                                }
570                                break;
571                        case 4:
572                                enterOuterAlt(_localctx, 4);
573                                {
574                                setState(183);
575                                li();
576                                }
577                                break;
578                        case 5:
579                                enterOuterAlt(_localctx, 5);
580                                {
581                                setState(184);
582                                tr();
583                                }
584                                break;
585                        case 6:
586                                enterOuterAlt(_localctx, 6);
587                                {
588                                setState(185);
589                                td();
590                                }
591                                break;
592                        case 7:
593                                enterOuterAlt(_localctx, 7);
594                                {
595                                setState(186);
596                                th();
597                                }
598                                break;
599                        case 8:
600                                enterOuterAlt(_localctx, 8);
601                                {
602                                setState(187);
603                                body();
604                                }
605                                break;
606                        case 9:
607                                enterOuterAlt(_localctx, 9);
608                                {
609                                setState(188);
610                                colgroup();
611                                }
612                                break;
613                        case 10:
614                                enterOuterAlt(_localctx, 10);
615                                {
616                                setState(189);
617                                dd();
618                                }
619                                break;
620                        case 11:
621                                enterOuterAlt(_localctx, 11);
622                                {
623                                setState(190);
624                                dt();
625                                }
626                                break;
627                        case 12:
628                                enterOuterAlt(_localctx, 12);
629                                {
630                                setState(191);
631                                head();
632                                }
633                                break;
634                        case 13:
635                                enterOuterAlt(_localctx, 13);
636                                {
637                                setState(192);
638                                html();
639                                }
640                                break;
641                        case 14:
642                                enterOuterAlt(_localctx, 14);
643                                {
644                                setState(193);
645                                option();
646                                }
647                                break;
648                        case 15:
649                                enterOuterAlt(_localctx, 15);
650                                {
651                                setState(194);
652                                tbody();
653                                }
654                                break;
655                        case 16:
656                                enterOuterAlt(_localctx, 16);
657                                {
658                                setState(195);
659                                thead();
660                                }
661                                break;
662                        case 17:
663                                enterOuterAlt(_localctx, 17);
664                                {
665                                setState(196);
666                                tfoot();
667                                }
668                                break;
669                        case 18:
670                                enterOuterAlt(_localctx, 18);
671                                {
672                                setState(197);
673                                pTagOpen();
674                                }
675                                break;
676                        case 19:
677                                enterOuterAlt(_localctx, 19);
678                                {
679                                setState(198);
680                                liTagOpen();
681                                }
682                                break;
683                        case 20:
684                                enterOuterAlt(_localctx, 20);
685                                {
686                                setState(199);
687                                trTagOpen();
688                                }
689                                break;
690                        case 21:
691                                enterOuterAlt(_localctx, 21);
692                                {
693                                setState(200);
694                                tdTagOpen();
695                                }
696                                break;
697                        case 22:
698                                enterOuterAlt(_localctx, 22);
699                                {
700                                setState(201);
701                                thTagOpen();
702                                }
703                                break;
704                        case 23:
705                                enterOuterAlt(_localctx, 23);
706                                {
707                                setState(202);
708                                bodyTagOpen();
709                                }
710                                break;
711                        case 24:
712                                enterOuterAlt(_localctx, 24);
713                                {
714                                setState(203);
715                                colgroupTagOpen();
716                                }
717                                break;
718                        case 25:
719                                enterOuterAlt(_localctx, 25);
720                                {
721                                setState(204);
722                                ddTagOpen();
723                                }
724                                break;
725                        case 26:
726                                enterOuterAlt(_localctx, 26);
727                                {
728                                setState(205);
729                                dtTagOpen();
730                                }
731                                break;
732                        case 27:
733                                enterOuterAlt(_localctx, 27);
734                                {
735                                setState(206);
736                                headTagOpen();
737                                }
738                                break;
739                        case 28:
740                                enterOuterAlt(_localctx, 28);
741                                {
742                                setState(207);
743                                htmlTagOpen();
744                                }
745                                break;
746                        case 29:
747                                enterOuterAlt(_localctx, 29);
748                                {
749                                setState(208);
750                                optionTagOpen();
751                                }
752                                break;
753                        case 30:
754                                enterOuterAlt(_localctx, 30);
755                                {
756                                setState(209);
757                                tbodyTagOpen();
758                                }
759                                break;
760                        case 31:
761                                enterOuterAlt(_localctx, 31);
762                                {
763                                setState(210);
764                                theadTagOpen();
765                                }
766                                break;
767                        case 32:
768                                enterOuterAlt(_localctx, 32);
769                                {
770                                setState(211);
771                                tfootTagOpen();
772                                }
773                                break;
774                        case 33:
775                                enterOuterAlt(_localctx, 33);
776                                {
777                                setState(212);
778                                pTagClose();
779                                }
780                                break;
781                        case 34:
782                                enterOuterAlt(_localctx, 34);
783                                {
784                                setState(213);
785                                liTagClose();
786                                }
787                                break;
788                        case 35:
789                                enterOuterAlt(_localctx, 35);
790                                {
791                                setState(214);
792                                trTagClose();
793                                }
794                                break;
795                        case 36:
796                                enterOuterAlt(_localctx, 36);
797                                {
798                                setState(215);
799                                tdTagClose();
800                                }
801                                break;
802                        case 37:
803                                enterOuterAlt(_localctx, 37);
804                                {
805                                setState(216);
806                                thTagClose();
807                                }
808                                break;
809                        case 38:
810                                enterOuterAlt(_localctx, 38);
811                                {
812                                setState(217);
813                                bodyTagClose();
814                                }
815                                break;
816                        case 39:
817                                enterOuterAlt(_localctx, 39);
818                                {
819                                setState(218);
820                                colgroupTagClose();
821                                }
822                                break;
823                        case 40:
824                                enterOuterAlt(_localctx, 40);
825                                {
826                                setState(219);
827                                ddTagClose();
828                                }
829                                break;
830                        case 41:
831                                enterOuterAlt(_localctx, 41);
832                                {
833                                setState(220);
834                                dtTagClose();
835                                }
836                                break;
837                        case 42:
838                                enterOuterAlt(_localctx, 42);
839                                {
840                                setState(221);
841                                headTagClose();
842                                }
843                                break;
844                        case 43:
845                                enterOuterAlt(_localctx, 43);
846                                {
847                                setState(222);
848                                htmlTagClose();
849                                }
850                                break;
851                        case 44:
852                                enterOuterAlt(_localctx, 44);
853                                {
854                                setState(223);
855                                optionTagClose();
856                                }
857                                break;
858                        case 45:
859                                enterOuterAlt(_localctx, 45);
860                                {
861                                setState(224);
862                                tbodyTagClose();
863                                }
864                                break;
865                        case 46:
866                                enterOuterAlt(_localctx, 46);
867                                {
868                                setState(225);
869                                theadTagClose();
870                                }
871                                break;
872                        case 47:
873                                enterOuterAlt(_localctx, 47);
874                                {
875                                setState(226);
876                                tfootTagClose();
877                                }
878                                break;
879                        }
880                }
881                catch (RecognitionException re) {
882                        _localctx.exception = re;
883                        _errHandler.reportError(this, re);
884                        _errHandler.recover(this, re);
885                }
886                finally {
887                        exitRule();
888                }
889                return _localctx;
890        }
891
892        public static class HtmlElementOpenContext extends ParserRuleContext {
893                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
894                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
895                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
896                public List<AttributeContext> attribute() {
897                        return getRuleContexts(AttributeContext.class);
898                }
899                public AttributeContext attribute(int i) {
900                        return getRuleContext(AttributeContext.class,i);
901                }
902                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
903                public TerminalNode NEWLINE(int i) {
904                        return getToken(JavadocParser.NEWLINE, i);
905                }
906                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
907                public TerminalNode LEADING_ASTERISK(int i) {
908                        return getToken(JavadocParser.LEADING_ASTERISK, i);
909                }
910                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
911                public TerminalNode WS(int i) {
912                        return getToken(JavadocParser.WS, i);
913                }
914                public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) {
915                        super(parent, invokingState);
916                }
917                @Override public int getRuleIndex() { return RULE_htmlElementOpen; }
918                @Override
919                public void enterRule(ParseTreeListener listener) {
920                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this);
921                }
922                @Override
923                public void exitRule(ParseTreeListener listener) {
924                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this);
925                }
926                @Override
927                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
928                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this);
929                        else return visitor.visitChildren(this);
930                }
931        }
932
933        public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException {
934                HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState());
935                enterRule(_localctx, 4, RULE_htmlElementOpen);
936                int _la;
937                try {
938                        enterOuterAlt(_localctx, 1);
939                        {
940                        setState(229);
941                        match(OPEN);
942                        setState(230);
943                        match(HTML_TAG_NAME);
944                        setState(237);
945                        _errHandler.sync(this);
946                        _la = _input.LA(1);
947                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
948                                {
949                                setState(235);
950                                switch (_input.LA(1)) {
951                                case HTML_TAG_NAME:
952                                        {
953                                        setState(231);
954                                        attribute();
955                                        }
956                                        break;
957                                case NEWLINE:
958                                        {
959                                        setState(232);
960                                        match(NEWLINE);
961                                        }
962                                        break;
963                                case LEADING_ASTERISK:
964                                        {
965                                        setState(233);
966                                        match(LEADING_ASTERISK);
967                                        }
968                                        break;
969                                case WS:
970                                        {
971                                        setState(234);
972                                        match(WS);
973                                        }
974                                        break;
975                                default:
976                                        throw new NoViableAltException(this);
977                                }
978                                }
979                                setState(239);
980                                _errHandler.sync(this);
981                                _la = _input.LA(1);
982                        }
983                        setState(240);
984                        match(CLOSE);
985                        }
986                }
987                catch (RecognitionException re) {
988                        _localctx.exception = re;
989                        _errHandler.reportError(this, re);
990                        _errHandler.recover(this, re);
991                }
992                finally {
993                        exitRule();
994                }
995                return _localctx;
996        }
997
998        public static class HtmlElementCloseContext extends ParserRuleContext {
999                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1000                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1001                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
1002                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1003                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1004                public TerminalNode NEWLINE(int i) {
1005                        return getToken(JavadocParser.NEWLINE, i);
1006                }
1007                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1008                public TerminalNode LEADING_ASTERISK(int i) {
1009                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1010                }
1011                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1012                public TerminalNode WS(int i) {
1013                        return getToken(JavadocParser.WS, i);
1014                }
1015                public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) {
1016                        super(parent, invokingState);
1017                }
1018                @Override public int getRuleIndex() { return RULE_htmlElementClose; }
1019                @Override
1020                public void enterRule(ParseTreeListener listener) {
1021                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this);
1022                }
1023                @Override
1024                public void exitRule(ParseTreeListener listener) {
1025                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this);
1026                }
1027                @Override
1028                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1029                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this);
1030                        else return visitor.visitChildren(this);
1031                }
1032        }
1033
1034        public final HtmlElementCloseContext htmlElementClose() throws RecognitionException {
1035                HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState());
1036                enterRule(_localctx, 6, RULE_htmlElementClose);
1037                int _la;
1038                try {
1039                        enterOuterAlt(_localctx, 1);
1040                        {
1041                        setState(242);
1042                        match(OPEN);
1043                        setState(243);
1044                        match(SLASH);
1045                        setState(244);
1046                        match(HTML_TAG_NAME);
1047                        setState(248);
1048                        _errHandler.sync(this);
1049                        _la = _input.LA(1);
1050                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1051                                {
1052                                {
1053                                setState(245);
1054                                _la = _input.LA(1);
1055                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1056                                _errHandler.recoverInline(this);
1057                                } else {
1058                                        consume();
1059                                }
1060                                }
1061                                }
1062                                setState(250);
1063                                _errHandler.sync(this);
1064                                _la = _input.LA(1);
1065                        }
1066                        setState(251);
1067                        match(CLOSE);
1068                        }
1069                }
1070                catch (RecognitionException re) {
1071                        _localctx.exception = re;
1072                        _errHandler.reportError(this, re);
1073                        _errHandler.recover(this, re);
1074                }
1075                finally {
1076                        exitRule();
1077                }
1078                return _localctx;
1079        }
1080
1081        public static class AttributeContext extends ParserRuleContext {
1082                public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
1083                public TerminalNode HTML_TAG_NAME(int i) {
1084                        return getToken(JavadocParser.HTML_TAG_NAME, i);
1085                }
1086                public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
1087                public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
1088                public TextContext text() {
1089                        return getRuleContext(TextContext.class,0);
1090                }
1091                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1092                public TerminalNode NEWLINE(int i) {
1093                        return getToken(JavadocParser.NEWLINE, i);
1094                }
1095                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1096                public TerminalNode LEADING_ASTERISK(int i) {
1097                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1098                }
1099                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1100                public TerminalNode WS(int i) {
1101                        return getToken(JavadocParser.WS, i);
1102                }
1103                public AttributeContext(ParserRuleContext parent, int invokingState) {
1104                        super(parent, invokingState);
1105                }
1106                @Override public int getRuleIndex() { return RULE_attribute; }
1107                @Override
1108                public void enterRule(ParseTreeListener listener) {
1109                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this);
1110                }
1111                @Override
1112                public void exitRule(ParseTreeListener listener) {
1113                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this);
1114                }
1115                @Override
1116                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1117                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this);
1118                        else return visitor.visitChildren(this);
1119                }
1120        }
1121
1122        public final AttributeContext attribute() throws RecognitionException {
1123                AttributeContext _localctx = new AttributeContext(_ctx, getState());
1124                enterRule(_localctx, 8, RULE_attribute);
1125                int _la;
1126                try {
1127                        int _alt;
1128                        enterOuterAlt(_localctx, 1);
1129                        {
1130                        setState(253);
1131                        match(HTML_TAG_NAME);
1132                        setState(257);
1133                        _errHandler.sync(this);
1134                        _la = _input.LA(1);
1135                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1136                                {
1137                                {
1138                                setState(254);
1139                                _la = _input.LA(1);
1140                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1141                                _errHandler.recoverInline(this);
1142                                } else {
1143                                        consume();
1144                                }
1145                                }
1146                                }
1147                                setState(259);
1148                                _errHandler.sync(this);
1149                                _la = _input.LA(1);
1150                        }
1151                        setState(260);
1152                        match(EQUALS);
1153                        setState(264);
1154                        _errHandler.sync(this);
1155                        _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1156                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1157                                if ( _alt==1 ) {
1158                                        {
1159                                        {
1160                                        setState(261);
1161                                        _la = _input.LA(1);
1162                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1163                                        _errHandler.recoverInline(this);
1164                                        } else {
1165                                                consume();
1166                                        }
1167                                        }
1168                                        } 
1169                                }
1170                                setState(266);
1171                                _errHandler.sync(this);
1172                                _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1173                        }
1174                        setState(270);
1175                        switch (_input.LA(1)) {
1176                        case ATTR_VALUE:
1177                                {
1178                                setState(267);
1179                                match(ATTR_VALUE);
1180                                }
1181                                break;
1182                        case WS:
1183                        case CHAR:
1184                                {
1185                                setState(268);
1186                                text();
1187                                }
1188                                break;
1189                        case HTML_TAG_NAME:
1190                                {
1191                                setState(269);
1192                                match(HTML_TAG_NAME);
1193                                }
1194                                break;
1195                        default:
1196                                throw new NoViableAltException(this);
1197                        }
1198                        }
1199                }
1200                catch (RecognitionException re) {
1201                        _localctx.exception = re;
1202                        _errHandler.reportError(this, re);
1203                        _errHandler.recover(this, re);
1204                }
1205                finally {
1206                        exitRule();
1207                }
1208                return _localctx;
1209        }
1210
1211        public static class HtmlTagContext extends ParserRuleContext {
1212                public HtmlElementOpenContext htmlElementOpen;
1213                public HtmlElementOpenContext htmlElementOpen() {
1214                        return getRuleContext(HtmlElementOpenContext.class,0);
1215                }
1216                public HtmlElementCloseContext htmlElementClose() {
1217                        return getRuleContext(HtmlElementCloseContext.class,0);
1218                }
1219                public List<HtmlElementContext> htmlElement() {
1220                        return getRuleContexts(HtmlElementContext.class);
1221                }
1222                public HtmlElementContext htmlElement(int i) {
1223                        return getRuleContext(HtmlElementContext.class,i);
1224                }
1225                public List<HtmlCommentContext> htmlComment() {
1226                        return getRuleContexts(HtmlCommentContext.class);
1227                }
1228                public HtmlCommentContext htmlComment(int i) {
1229                        return getRuleContext(HtmlCommentContext.class,i);
1230                }
1231                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1232                public TerminalNode CDATA(int i) {
1233                        return getToken(JavadocParser.CDATA, i);
1234                }
1235                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1236                public TerminalNode NEWLINE(int i) {
1237                        return getToken(JavadocParser.NEWLINE, i);
1238                }
1239                public List<TextContext> text() {
1240                        return getRuleContexts(TextContext.class);
1241                }
1242                public TextContext text(int i) {
1243                        return getRuleContext(TextContext.class,i);
1244                }
1245                public List<JavadocInlineTagContext> javadocInlineTag() {
1246                        return getRuleContexts(JavadocInlineTagContext.class);
1247                }
1248                public JavadocInlineTagContext javadocInlineTag(int i) {
1249                        return getRuleContext(JavadocInlineTagContext.class,i);
1250                }
1251                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1252                public TerminalNode LEADING_ASTERISK(int i) {
1253                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1254                }
1255                public HtmlTagContext(ParserRuleContext parent, int invokingState) {
1256                        super(parent, invokingState);
1257                }
1258                @Override public int getRuleIndex() { return RULE_htmlTag; }
1259                @Override
1260                public void enterRule(ParseTreeListener listener) {
1261                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this);
1262                }
1263                @Override
1264                public void exitRule(ParseTreeListener listener) {
1265                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this);
1266                }
1267                @Override
1268                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1269                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this);
1270                        else return visitor.visitChildren(this);
1271                }
1272        }
1273
1274        public final HtmlTagContext htmlTag() throws RecognitionException {
1275                HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1276                enterRule(_localctx, 10, RULE_htmlTag);
1277                try {
1278                        int _alt;
1279                        setState(304);
1280                        switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
1281                        case 1:
1282                                enterOuterAlt(_localctx, 1);
1283                                {
1284                                setState(272);
1285                                htmlElementOpen();
1286                                setState(283);
1287                                _errHandler.sync(this);
1288                                _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1289                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1290                                        if ( _alt==1 ) {
1291                                                {
1292                                                setState(281);
1293                                                switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1294                                                case 1:
1295                                                        {
1296                                                        setState(273);
1297                                                        htmlElement();
1298                                                        }
1299                                                        break;
1300                                                case 2:
1301                                                        {
1302                                                        {
1303                                                        setState(274);
1304                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1305                                                        setState(275);
1306                                                        match(LEADING_ASTERISK);
1307                                                        }
1308                                                        }
1309                                                        break;
1310                                                case 3:
1311                                                        {
1312                                                        setState(276);
1313                                                        htmlComment();
1314                                                        }
1315                                                        break;
1316                                                case 4:
1317                                                        {
1318                                                        setState(277);
1319                                                        match(CDATA);
1320                                                        }
1321                                                        break;
1322                                                case 5:
1323                                                        {
1324                                                        setState(278);
1325                                                        match(NEWLINE);
1326                                                        }
1327                                                        break;
1328                                                case 6:
1329                                                        {
1330                                                        setState(279);
1331                                                        text();
1332                                                        }
1333                                                        break;
1334                                                case 7:
1335                                                        {
1336                                                        setState(280);
1337                                                        javadocInlineTag();
1338                                                        }
1339                                                        break;
1340                                                }
1341                                                } 
1342                                        }
1343                                        setState(285);
1344                                        _errHandler.sync(this);
1345                                        _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1346                                }
1347                                setState(286);
1348                                htmlElementClose();
1349                                }
1350                                break;
1351                        case 2:
1352                                enterOuterAlt(_localctx, 2);
1353                                {
1354                                setState(288);
1355                                ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen();
1356                                setState(299);
1357                                _errHandler.sync(this);
1358                                _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1359                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1360                                        if ( _alt==1 ) {
1361                                                {
1362                                                setState(297);
1363                                                switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
1364                                                case 1:
1365                                                        {
1366                                                        setState(289);
1367                                                        htmlElement();
1368                                                        }
1369                                                        break;
1370                                                case 2:
1371                                                        {
1372                                                        {
1373                                                        setState(290);
1374                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1375                                                        setState(291);
1376                                                        match(LEADING_ASTERISK);
1377                                                        }
1378                                                        }
1379                                                        break;
1380                                                case 3:
1381                                                        {
1382                                                        setState(292);
1383                                                        htmlComment();
1384                                                        }
1385                                                        break;
1386                                                case 4:
1387                                                        {
1388                                                        setState(293);
1389                                                        match(CDATA);
1390                                                        }
1391                                                        break;
1392                                                case 5:
1393                                                        {
1394                                                        setState(294);
1395                                                        match(NEWLINE);
1396                                                        }
1397                                                        break;
1398                                                case 6:
1399                                                        {
1400                                                        setState(295);
1401                                                        text();
1402                                                        }
1403                                                        break;
1404                                                case 7:
1405                                                        {
1406                                                        setState(296);
1407                                                        javadocInlineTag();
1408                                                        }
1409                                                        break;
1410                                                }
1411                                                } 
1412                                        }
1413                                        setState(301);
1414                                        _errHandler.sync(this);
1415                                        _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1416                                }
1417                                notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol(), "javadoc.missed.html.close", null);
1418                                }
1419                                break;
1420                        }
1421                }
1422                catch (RecognitionException re) {
1423                        _localctx.exception = re;
1424                        _errHandler.reportError(this, re);
1425                        _errHandler.recover(this, re);
1426                }
1427                finally {
1428                        exitRule();
1429                }
1430                return _localctx;
1431        }
1432
1433        public static class PTagOpenContext extends ParserRuleContext {
1434                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1435                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1436                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1437                public List<AttributeContext> attribute() {
1438                        return getRuleContexts(AttributeContext.class);
1439                }
1440                public AttributeContext attribute(int i) {
1441                        return getRuleContext(AttributeContext.class,i);
1442                }
1443                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1444                public TerminalNode NEWLINE(int i) {
1445                        return getToken(JavadocParser.NEWLINE, i);
1446                }
1447                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1448                public TerminalNode LEADING_ASTERISK(int i) {
1449                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1450                }
1451                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1452                public TerminalNode WS(int i) {
1453                        return getToken(JavadocParser.WS, i);
1454                }
1455                public PTagOpenContext(ParserRuleContext parent, int invokingState) {
1456                        super(parent, invokingState);
1457                }
1458                @Override public int getRuleIndex() { return RULE_pTagOpen; }
1459                @Override
1460                public void enterRule(ParseTreeListener listener) {
1461                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this);
1462                }
1463                @Override
1464                public void exitRule(ParseTreeListener listener) {
1465                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this);
1466                }
1467                @Override
1468                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1469                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this);
1470                        else return visitor.visitChildren(this);
1471                }
1472        }
1473
1474        public final PTagOpenContext pTagOpen() throws RecognitionException {
1475                PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState());
1476                enterRule(_localctx, 12, RULE_pTagOpen);
1477                int _la;
1478                try {
1479                        enterOuterAlt(_localctx, 1);
1480                        {
1481                        setState(306);
1482                        match(OPEN);
1483                        setState(307);
1484                        match(P_HTML_TAG_NAME);
1485                        setState(314);
1486                        _errHandler.sync(this);
1487                        _la = _input.LA(1);
1488                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1489                                {
1490                                setState(312);
1491                                switch (_input.LA(1)) {
1492                                case HTML_TAG_NAME:
1493                                        {
1494                                        setState(308);
1495                                        attribute();
1496                                        }
1497                                        break;
1498                                case NEWLINE:
1499                                        {
1500                                        setState(309);
1501                                        match(NEWLINE);
1502                                        }
1503                                        break;
1504                                case LEADING_ASTERISK:
1505                                        {
1506                                        setState(310);
1507                                        match(LEADING_ASTERISK);
1508                                        }
1509                                        break;
1510                                case WS:
1511                                        {
1512                                        setState(311);
1513                                        match(WS);
1514                                        }
1515                                        break;
1516                                default:
1517                                        throw new NoViableAltException(this);
1518                                }
1519                                }
1520                                setState(316);
1521                                _errHandler.sync(this);
1522                                _la = _input.LA(1);
1523                        }
1524                        setState(317);
1525                        match(CLOSE);
1526                        }
1527                }
1528                catch (RecognitionException re) {
1529                        _localctx.exception = re;
1530                        _errHandler.reportError(this, re);
1531                        _errHandler.recover(this, re);
1532                }
1533                finally {
1534                        exitRule();
1535                }
1536                return _localctx;
1537        }
1538
1539        public static class PTagCloseContext extends ParserRuleContext {
1540                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1541                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1542                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1543                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1544                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1545                public TerminalNode NEWLINE(int i) {
1546                        return getToken(JavadocParser.NEWLINE, i);
1547                }
1548                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1549                public TerminalNode LEADING_ASTERISK(int i) {
1550                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1551                }
1552                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1553                public TerminalNode WS(int i) {
1554                        return getToken(JavadocParser.WS, i);
1555                }
1556                public PTagCloseContext(ParserRuleContext parent, int invokingState) {
1557                        super(parent, invokingState);
1558                }
1559                @Override public int getRuleIndex() { return RULE_pTagClose; }
1560                @Override
1561                public void enterRule(ParseTreeListener listener) {
1562                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this);
1563                }
1564                @Override
1565                public void exitRule(ParseTreeListener listener) {
1566                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this);
1567                }
1568                @Override
1569                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1570                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this);
1571                        else return visitor.visitChildren(this);
1572                }
1573        }
1574
1575        public final PTagCloseContext pTagClose() throws RecognitionException {
1576                PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState());
1577                enterRule(_localctx, 14, RULE_pTagClose);
1578                int _la;
1579                try {
1580                        enterOuterAlt(_localctx, 1);
1581                        {
1582                        setState(319);
1583                        match(OPEN);
1584                        setState(320);
1585                        match(SLASH);
1586                        setState(321);
1587                        match(P_HTML_TAG_NAME);
1588                        setState(325);
1589                        _errHandler.sync(this);
1590                        _la = _input.LA(1);
1591                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1592                                {
1593                                {
1594                                setState(322);
1595                                _la = _input.LA(1);
1596                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1597                                _errHandler.recoverInline(this);
1598                                } else {
1599                                        consume();
1600                                }
1601                                }
1602                                }
1603                                setState(327);
1604                                _errHandler.sync(this);
1605                                _la = _input.LA(1);
1606                        }
1607                        setState(328);
1608                        match(CLOSE);
1609                        }
1610                }
1611                catch (RecognitionException re) {
1612                        _localctx.exception = re;
1613                        _errHandler.reportError(this, re);
1614                        _errHandler.recover(this, re);
1615                }
1616                finally {
1617                        exitRule();
1618                }
1619                return _localctx;
1620        }
1621
1622        public static class ParagraphContext extends ParserRuleContext {
1623                public PTagOpenContext pTagOpen() {
1624                        return getRuleContext(PTagOpenContext.class,0);
1625                }
1626                public PTagCloseContext pTagClose() {
1627                        return getRuleContext(PTagCloseContext.class,0);
1628                }
1629                public List<HtmlTagContext> htmlTag() {
1630                        return getRuleContexts(HtmlTagContext.class);
1631                }
1632                public HtmlTagContext htmlTag(int i) {
1633                        return getRuleContext(HtmlTagContext.class,i);
1634                }
1635                public List<SingletonTagContext> singletonTag() {
1636                        return getRuleContexts(SingletonTagContext.class);
1637                }
1638                public SingletonTagContext singletonTag(int i) {
1639                        return getRuleContext(SingletonTagContext.class,i);
1640                }
1641                public List<LiContext> li() {
1642                        return getRuleContexts(LiContext.class);
1643                }
1644                public LiContext li(int i) {
1645                        return getRuleContext(LiContext.class,i);
1646                }
1647                public List<TrContext> tr() {
1648                        return getRuleContexts(TrContext.class);
1649                }
1650                public TrContext tr(int i) {
1651                        return getRuleContext(TrContext.class,i);
1652                }
1653                public List<TdContext> td() {
1654                        return getRuleContexts(TdContext.class);
1655                }
1656                public TdContext td(int i) {
1657                        return getRuleContext(TdContext.class,i);
1658                }
1659                public List<ThContext> th() {
1660                        return getRuleContexts(ThContext.class);
1661                }
1662                public ThContext th(int i) {
1663                        return getRuleContext(ThContext.class,i);
1664                }
1665                public List<BodyContext> body() {
1666                        return getRuleContexts(BodyContext.class);
1667                }
1668                public BodyContext body(int i) {
1669                        return getRuleContext(BodyContext.class,i);
1670                }
1671                public List<ColgroupContext> colgroup() {
1672                        return getRuleContexts(ColgroupContext.class);
1673                }
1674                public ColgroupContext colgroup(int i) {
1675                        return getRuleContext(ColgroupContext.class,i);
1676                }
1677                public List<DdContext> dd() {
1678                        return getRuleContexts(DdContext.class);
1679                }
1680                public DdContext dd(int i) {
1681                        return getRuleContext(DdContext.class,i);
1682                }
1683                public List<DtContext> dt() {
1684                        return getRuleContexts(DtContext.class);
1685                }
1686                public DtContext dt(int i) {
1687                        return getRuleContext(DtContext.class,i);
1688                }
1689                public List<HeadContext> head() {
1690                        return getRuleContexts(HeadContext.class);
1691                }
1692                public HeadContext head(int i) {
1693                        return getRuleContext(HeadContext.class,i);
1694                }
1695                public List<HtmlContext> html() {
1696                        return getRuleContexts(HtmlContext.class);
1697                }
1698                public HtmlContext html(int i) {
1699                        return getRuleContext(HtmlContext.class,i);
1700                }
1701                public List<OptionContext> option() {
1702                        return getRuleContexts(OptionContext.class);
1703                }
1704                public OptionContext option(int i) {
1705                        return getRuleContext(OptionContext.class,i);
1706                }
1707                public List<TbodyContext> tbody() {
1708                        return getRuleContexts(TbodyContext.class);
1709                }
1710                public TbodyContext tbody(int i) {
1711                        return getRuleContext(TbodyContext.class,i);
1712                }
1713                public List<TheadContext> thead() {
1714                        return getRuleContexts(TheadContext.class);
1715                }
1716                public TheadContext thead(int i) {
1717                        return getRuleContext(TheadContext.class,i);
1718                }
1719                public List<TfootContext> tfoot() {
1720                        return getRuleContexts(TfootContext.class);
1721                }
1722                public TfootContext tfoot(int i) {
1723                        return getRuleContext(TfootContext.class,i);
1724                }
1725                public List<LiTagOpenContext> liTagOpen() {
1726                        return getRuleContexts(LiTagOpenContext.class);
1727                }
1728                public LiTagOpenContext liTagOpen(int i) {
1729                        return getRuleContext(LiTagOpenContext.class,i);
1730                }
1731                public List<TrTagOpenContext> trTagOpen() {
1732                        return getRuleContexts(TrTagOpenContext.class);
1733                }
1734                public TrTagOpenContext trTagOpen(int i) {
1735                        return getRuleContext(TrTagOpenContext.class,i);
1736                }
1737                public List<TdTagOpenContext> tdTagOpen() {
1738                        return getRuleContexts(TdTagOpenContext.class);
1739                }
1740                public TdTagOpenContext tdTagOpen(int i) {
1741                        return getRuleContext(TdTagOpenContext.class,i);
1742                }
1743                public List<ThTagOpenContext> thTagOpen() {
1744                        return getRuleContexts(ThTagOpenContext.class);
1745                }
1746                public ThTagOpenContext thTagOpen(int i) {
1747                        return getRuleContext(ThTagOpenContext.class,i);
1748                }
1749                public List<BodyTagOpenContext> bodyTagOpen() {
1750                        return getRuleContexts(BodyTagOpenContext.class);
1751                }
1752                public BodyTagOpenContext bodyTagOpen(int i) {
1753                        return getRuleContext(BodyTagOpenContext.class,i);
1754                }
1755                public List<ColgroupTagOpenContext> colgroupTagOpen() {
1756                        return getRuleContexts(ColgroupTagOpenContext.class);
1757                }
1758                public ColgroupTagOpenContext colgroupTagOpen(int i) {
1759                        return getRuleContext(ColgroupTagOpenContext.class,i);
1760                }
1761                public List<DdTagOpenContext> ddTagOpen() {
1762                        return getRuleContexts(DdTagOpenContext.class);
1763                }
1764                public DdTagOpenContext ddTagOpen(int i) {
1765                        return getRuleContext(DdTagOpenContext.class,i);
1766                }
1767                public List<DtTagOpenContext> dtTagOpen() {
1768                        return getRuleContexts(DtTagOpenContext.class);
1769                }
1770                public DtTagOpenContext dtTagOpen(int i) {
1771                        return getRuleContext(DtTagOpenContext.class,i);
1772                }
1773                public List<HeadTagOpenContext> headTagOpen() {
1774                        return getRuleContexts(HeadTagOpenContext.class);
1775                }
1776                public HeadTagOpenContext headTagOpen(int i) {
1777                        return getRuleContext(HeadTagOpenContext.class,i);
1778                }
1779                public List<HtmlTagOpenContext> htmlTagOpen() {
1780                        return getRuleContexts(HtmlTagOpenContext.class);
1781                }
1782                public HtmlTagOpenContext htmlTagOpen(int i) {
1783                        return getRuleContext(HtmlTagOpenContext.class,i);
1784                }
1785                public List<OptionTagOpenContext> optionTagOpen() {
1786                        return getRuleContexts(OptionTagOpenContext.class);
1787                }
1788                public OptionTagOpenContext optionTagOpen(int i) {
1789                        return getRuleContext(OptionTagOpenContext.class,i);
1790                }
1791                public List<TbodyTagOpenContext> tbodyTagOpen() {
1792                        return getRuleContexts(TbodyTagOpenContext.class);
1793                }
1794                public TbodyTagOpenContext tbodyTagOpen(int i) {
1795                        return getRuleContext(TbodyTagOpenContext.class,i);
1796                }
1797                public List<TheadTagOpenContext> theadTagOpen() {
1798                        return getRuleContexts(TheadTagOpenContext.class);
1799                }
1800                public TheadTagOpenContext theadTagOpen(int i) {
1801                        return getRuleContext(TheadTagOpenContext.class,i);
1802                }
1803                public List<TfootTagOpenContext> tfootTagOpen() {
1804                        return getRuleContexts(TfootTagOpenContext.class);
1805                }
1806                public TfootTagOpenContext tfootTagOpen(int i) {
1807                        return getRuleContext(TfootTagOpenContext.class,i);
1808                }
1809                public List<HtmlCommentContext> htmlComment() {
1810                        return getRuleContexts(HtmlCommentContext.class);
1811                }
1812                public HtmlCommentContext htmlComment(int i) {
1813                        return getRuleContext(HtmlCommentContext.class,i);
1814                }
1815                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1816                public TerminalNode CDATA(int i) {
1817                        return getToken(JavadocParser.CDATA, i);
1818                }
1819                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1820                public TerminalNode NEWLINE(int i) {
1821                        return getToken(JavadocParser.NEWLINE, i);
1822                }
1823                public List<TextContext> text() {
1824                        return getRuleContexts(TextContext.class);
1825                }
1826                public TextContext text(int i) {
1827                        return getRuleContext(TextContext.class,i);
1828                }
1829                public List<JavadocInlineTagContext> javadocInlineTag() {
1830                        return getRuleContexts(JavadocInlineTagContext.class);
1831                }
1832                public JavadocInlineTagContext javadocInlineTag(int i) {
1833                        return getRuleContext(JavadocInlineTagContext.class,i);
1834                }
1835                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1836                public TerminalNode LEADING_ASTERISK(int i) {
1837                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1838                }
1839                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1840                        super(parent, invokingState);
1841                }
1842                @Override public int getRuleIndex() { return RULE_paragraph; }
1843                @Override
1844                public void enterRule(ParseTreeListener listener) {
1845                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this);
1846                }
1847                @Override
1848                public void exitRule(ParseTreeListener listener) {
1849                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this);
1850                }
1851                @Override
1852                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1853                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this);
1854                        else return visitor.visitChildren(this);
1855                }
1856        }
1857
1858        public final ParagraphContext paragraph() throws RecognitionException {
1859                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1860                enterRule(_localctx, 16, RULE_paragraph);
1861                try {
1862                        int _alt;
1863                        enterOuterAlt(_localctx, 1);
1864                        {
1865                        setState(330);
1866                        pTagOpen();
1867                        setState(370);
1868                        _errHandler.sync(this);
1869                        _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1870                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1871                                if ( _alt==1 ) {
1872                                        {
1873                                        setState(368);
1874                                        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
1875                                        case 1:
1876                                                {
1877                                                setState(331);
1878                                                htmlTag();
1879                                                }
1880                                                break;
1881                                        case 2:
1882                                                {
1883                                                setState(332);
1884                                                singletonTag();
1885                                                }
1886                                                break;
1887                                        case 3:
1888                                                {
1889                                                setState(333);
1890                                                li();
1891                                                }
1892                                                break;
1893                                        case 4:
1894                                                {
1895                                                setState(334);
1896                                                tr();
1897                                                }
1898                                                break;
1899                                        case 5:
1900                                                {
1901                                                setState(335);
1902                                                td();
1903                                                }
1904                                                break;
1905                                        case 6:
1906                                                {
1907                                                setState(336);
1908                                                th();
1909                                                }
1910                                                break;
1911                                        case 7:
1912                                                {
1913                                                setState(337);
1914                                                body();
1915                                                }
1916                                                break;
1917                                        case 8:
1918                                                {
1919                                                setState(338);
1920                                                colgroup();
1921                                                }
1922                                                break;
1923                                        case 9:
1924                                                {
1925                                                setState(339);
1926                                                dd();
1927                                                }
1928                                                break;
1929                                        case 10:
1930                                                {
1931                                                setState(340);
1932                                                dt();
1933                                                }
1934                                                break;
1935                                        case 11:
1936                                                {
1937                                                setState(341);
1938                                                head();
1939                                                }
1940                                                break;
1941                                        case 12:
1942                                                {
1943                                                setState(342);
1944                                                html();
1945                                                }
1946                                                break;
1947                                        case 13:
1948                                                {
1949                                                setState(343);
1950                                                option();
1951                                                }
1952                                                break;
1953                                        case 14:
1954                                                {
1955                                                setState(344);
1956                                                tbody();
1957                                                }
1958                                                break;
1959                                        case 15:
1960                                                {
1961                                                setState(345);
1962                                                thead();
1963                                                }
1964                                                break;
1965                                        case 16:
1966                                                {
1967                                                setState(346);
1968                                                tfoot();
1969                                                }
1970                                                break;
1971                                        case 17:
1972                                                {
1973                                                setState(347);
1974                                                liTagOpen();
1975                                                }
1976                                                break;
1977                                        case 18:
1978                                                {
1979                                                setState(348);
1980                                                trTagOpen();
1981                                                }
1982                                                break;
1983                                        case 19:
1984                                                {
1985                                                setState(349);
1986                                                tdTagOpen();
1987                                                }
1988                                                break;
1989                                        case 20:
1990                                                {
1991                                                setState(350);
1992                                                thTagOpen();
1993                                                }
1994                                                break;
1995                                        case 21:
1996                                                {
1997                                                setState(351);
1998                                                bodyTagOpen();
1999                                                }
2000                                                break;
2001                                        case 22:
2002                                                {
2003                                                setState(352);
2004                                                colgroupTagOpen();
2005                                                }
2006                                                break;
2007                                        case 23:
2008                                                {
2009                                                setState(353);
2010                                                ddTagOpen();
2011                                                }
2012                                                break;
2013                                        case 24:
2014                                                {
2015                                                setState(354);
2016                                                dtTagOpen();
2017                                                }
2018                                                break;
2019                                        case 25:
2020                                                {
2021                                                setState(355);
2022                                                headTagOpen();
2023                                                }
2024                                                break;
2025                                        case 26:
2026                                                {
2027                                                setState(356);
2028                                                htmlTagOpen();
2029                                                }
2030                                                break;
2031                                        case 27:
2032                                                {
2033                                                setState(357);
2034                                                optionTagOpen();
2035                                                }
2036                                                break;
2037                                        case 28:
2038                                                {
2039                                                setState(358);
2040                                                tbodyTagOpen();
2041                                                }
2042                                                break;
2043                                        case 29:
2044                                                {
2045                                                setState(359);
2046                                                theadTagOpen();
2047                                                }
2048                                                break;
2049                                        case 30:
2050                                                {
2051                                                setState(360);
2052                                                tfootTagOpen();
2053                                                }
2054                                                break;
2055                                        case 31:
2056                                                {
2057                                                {
2058                                                setState(361);
2059                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2060                                                setState(362);
2061                                                match(LEADING_ASTERISK);
2062                                                }
2063                                                }
2064                                                break;
2065                                        case 32:
2066                                                {
2067                                                setState(363);
2068                                                htmlComment();
2069                                                }
2070                                                break;
2071                                        case 33:
2072                                                {
2073                                                setState(364);
2074                                                match(CDATA);
2075                                                }
2076                                                break;
2077                                        case 34:
2078                                                {
2079                                                setState(365);
2080                                                match(NEWLINE);
2081                                                }
2082                                                break;
2083                                        case 35:
2084                                                {
2085                                                setState(366);
2086                                                text();
2087                                                }
2088                                                break;
2089                                        case 36:
2090                                                {
2091                                                setState(367);
2092                                                javadocInlineTag();
2093                                                }
2094                                                break;
2095                                        }
2096                                        } 
2097                                }
2098                                setState(372);
2099                                _errHandler.sync(this);
2100                                _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
2101                        }
2102                        setState(373);
2103                        pTagClose();
2104                        }
2105                }
2106                catch (RecognitionException re) {
2107                        _localctx.exception = re;
2108                        _errHandler.reportError(this, re);
2109                        _errHandler.recover(this, re);
2110                }
2111                finally {
2112                        exitRule();
2113                }
2114                return _localctx;
2115        }
2116
2117        public static class LiTagOpenContext extends ParserRuleContext {
2118                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2119                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2120                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2121                public List<AttributeContext> attribute() {
2122                        return getRuleContexts(AttributeContext.class);
2123                }
2124                public AttributeContext attribute(int i) {
2125                        return getRuleContext(AttributeContext.class,i);
2126                }
2127                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2128                public TerminalNode NEWLINE(int i) {
2129                        return getToken(JavadocParser.NEWLINE, i);
2130                }
2131                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2132                public TerminalNode LEADING_ASTERISK(int i) {
2133                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2134                }
2135                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2136                public TerminalNode WS(int i) {
2137                        return getToken(JavadocParser.WS, i);
2138                }
2139                public LiTagOpenContext(ParserRuleContext parent, int invokingState) {
2140                        super(parent, invokingState);
2141                }
2142                @Override public int getRuleIndex() { return RULE_liTagOpen; }
2143                @Override
2144                public void enterRule(ParseTreeListener listener) {
2145                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this);
2146                }
2147                @Override
2148                public void exitRule(ParseTreeListener listener) {
2149                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this);
2150                }
2151                @Override
2152                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2153                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this);
2154                        else return visitor.visitChildren(this);
2155                }
2156        }
2157
2158        public final LiTagOpenContext liTagOpen() throws RecognitionException {
2159                LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState());
2160                enterRule(_localctx, 18, RULE_liTagOpen);
2161                int _la;
2162                try {
2163                        enterOuterAlt(_localctx, 1);
2164                        {
2165                        setState(375);
2166                        match(OPEN);
2167                        setState(376);
2168                        match(LI_HTML_TAG_NAME);
2169                        setState(383);
2170                        _errHandler.sync(this);
2171                        _la = _input.LA(1);
2172                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2173                                {
2174                                setState(381);
2175                                switch (_input.LA(1)) {
2176                                case HTML_TAG_NAME:
2177                                        {
2178                                        setState(377);
2179                                        attribute();
2180                                        }
2181                                        break;
2182                                case NEWLINE:
2183                                        {
2184                                        setState(378);
2185                                        match(NEWLINE);
2186                                        }
2187                                        break;
2188                                case LEADING_ASTERISK:
2189                                        {
2190                                        setState(379);
2191                                        match(LEADING_ASTERISK);
2192                                        }
2193                                        break;
2194                                case WS:
2195                                        {
2196                                        setState(380);
2197                                        match(WS);
2198                                        }
2199                                        break;
2200                                default:
2201                                        throw new NoViableAltException(this);
2202                                }
2203                                }
2204                                setState(385);
2205                                _errHandler.sync(this);
2206                                _la = _input.LA(1);
2207                        }
2208                        setState(386);
2209                        match(CLOSE);
2210                        }
2211                }
2212                catch (RecognitionException re) {
2213                        _localctx.exception = re;
2214                        _errHandler.reportError(this, re);
2215                        _errHandler.recover(this, re);
2216                }
2217                finally {
2218                        exitRule();
2219                }
2220                return _localctx;
2221        }
2222
2223        public static class LiTagCloseContext extends ParserRuleContext {
2224                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2225                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2226                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2227                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2228                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2229                public TerminalNode NEWLINE(int i) {
2230                        return getToken(JavadocParser.NEWLINE, i);
2231                }
2232                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2233                public TerminalNode LEADING_ASTERISK(int i) {
2234                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2235                }
2236                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2237                public TerminalNode WS(int i) {
2238                        return getToken(JavadocParser.WS, i);
2239                }
2240                public LiTagCloseContext(ParserRuleContext parent, int invokingState) {
2241                        super(parent, invokingState);
2242                }
2243                @Override public int getRuleIndex() { return RULE_liTagClose; }
2244                @Override
2245                public void enterRule(ParseTreeListener listener) {
2246                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this);
2247                }
2248                @Override
2249                public void exitRule(ParseTreeListener listener) {
2250                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this);
2251                }
2252                @Override
2253                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2254                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this);
2255                        else return visitor.visitChildren(this);
2256                }
2257        }
2258
2259        public final LiTagCloseContext liTagClose() throws RecognitionException {
2260                LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState());
2261                enterRule(_localctx, 20, RULE_liTagClose);
2262                int _la;
2263                try {
2264                        enterOuterAlt(_localctx, 1);
2265                        {
2266                        setState(388);
2267                        match(OPEN);
2268                        setState(389);
2269                        match(SLASH);
2270                        setState(390);
2271                        match(LI_HTML_TAG_NAME);
2272                        setState(394);
2273                        _errHandler.sync(this);
2274                        _la = _input.LA(1);
2275                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2276                                {
2277                                {
2278                                setState(391);
2279                                _la = _input.LA(1);
2280                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2281                                _errHandler.recoverInline(this);
2282                                } else {
2283                                        consume();
2284                                }
2285                                }
2286                                }
2287                                setState(396);
2288                                _errHandler.sync(this);
2289                                _la = _input.LA(1);
2290                        }
2291                        setState(397);
2292                        match(CLOSE);
2293                        }
2294                }
2295                catch (RecognitionException re) {
2296                        _localctx.exception = re;
2297                        _errHandler.reportError(this, re);
2298                        _errHandler.recover(this, re);
2299                }
2300                finally {
2301                        exitRule();
2302                }
2303                return _localctx;
2304        }
2305
2306        public static class LiContext extends ParserRuleContext {
2307                public LiTagOpenContext liTagOpen() {
2308                        return getRuleContext(LiTagOpenContext.class,0);
2309                }
2310                public LiTagCloseContext liTagClose() {
2311                        return getRuleContext(LiTagCloseContext.class,0);
2312                }
2313                public List<HtmlTagContext> htmlTag() {
2314                        return getRuleContexts(HtmlTagContext.class);
2315                }
2316                public HtmlTagContext htmlTag(int i) {
2317                        return getRuleContext(HtmlTagContext.class,i);
2318                }
2319                public List<SingletonTagContext> singletonTag() {
2320                        return getRuleContexts(SingletonTagContext.class);
2321                }
2322                public SingletonTagContext singletonTag(int i) {
2323                        return getRuleContext(SingletonTagContext.class,i);
2324                }
2325                public List<ParagraphContext> paragraph() {
2326                        return getRuleContexts(ParagraphContext.class);
2327                }
2328                public ParagraphContext paragraph(int i) {
2329                        return getRuleContext(ParagraphContext.class,i);
2330                }
2331                public List<TrContext> tr() {
2332                        return getRuleContexts(TrContext.class);
2333                }
2334                public TrContext tr(int i) {
2335                        return getRuleContext(TrContext.class,i);
2336                }
2337                public List<TdContext> td() {
2338                        return getRuleContexts(TdContext.class);
2339                }
2340                public TdContext td(int i) {
2341                        return getRuleContext(TdContext.class,i);
2342                }
2343                public List<ThContext> th() {
2344                        return getRuleContexts(ThContext.class);
2345                }
2346                public ThContext th(int i) {
2347                        return getRuleContext(ThContext.class,i);
2348                }
2349                public List<BodyContext> body() {
2350                        return getRuleContexts(BodyContext.class);
2351                }
2352                public BodyContext body(int i) {
2353                        return getRuleContext(BodyContext.class,i);
2354                }
2355                public List<ColgroupContext> colgroup() {
2356                        return getRuleContexts(ColgroupContext.class);
2357                }
2358                public ColgroupContext colgroup(int i) {
2359                        return getRuleContext(ColgroupContext.class,i);
2360                }
2361                public List<DdContext> dd() {
2362                        return getRuleContexts(DdContext.class);
2363                }
2364                public DdContext dd(int i) {
2365                        return getRuleContext(DdContext.class,i);
2366                }
2367                public List<DtContext> dt() {
2368                        return getRuleContexts(DtContext.class);
2369                }
2370                public DtContext dt(int i) {
2371                        return getRuleContext(DtContext.class,i);
2372                }
2373                public List<HeadContext> head() {
2374                        return getRuleContexts(HeadContext.class);
2375                }
2376                public HeadContext head(int i) {
2377                        return getRuleContext(HeadContext.class,i);
2378                }
2379                public List<HtmlContext> html() {
2380                        return getRuleContexts(HtmlContext.class);
2381                }
2382                public HtmlContext html(int i) {
2383                        return getRuleContext(HtmlContext.class,i);
2384                }
2385                public List<OptionContext> option() {
2386                        return getRuleContexts(OptionContext.class);
2387                }
2388                public OptionContext option(int i) {
2389                        return getRuleContext(OptionContext.class,i);
2390                }
2391                public List<TbodyContext> tbody() {
2392                        return getRuleContexts(TbodyContext.class);
2393                }
2394                public TbodyContext tbody(int i) {
2395                        return getRuleContext(TbodyContext.class,i);
2396                }
2397                public List<TheadContext> thead() {
2398                        return getRuleContexts(TheadContext.class);
2399                }
2400                public TheadContext thead(int i) {
2401                        return getRuleContext(TheadContext.class,i);
2402                }
2403                public List<TfootContext> tfoot() {
2404                        return getRuleContexts(TfootContext.class);
2405                }
2406                public TfootContext tfoot(int i) {
2407                        return getRuleContext(TfootContext.class,i);
2408                }
2409                public List<PTagOpenContext> pTagOpen() {
2410                        return getRuleContexts(PTagOpenContext.class);
2411                }
2412                public PTagOpenContext pTagOpen(int i) {
2413                        return getRuleContext(PTagOpenContext.class,i);
2414                }
2415                public List<TrTagOpenContext> trTagOpen() {
2416                        return getRuleContexts(TrTagOpenContext.class);
2417                }
2418                public TrTagOpenContext trTagOpen(int i) {
2419                        return getRuleContext(TrTagOpenContext.class,i);
2420                }
2421                public List<TdTagOpenContext> tdTagOpen() {
2422                        return getRuleContexts(TdTagOpenContext.class);
2423                }
2424                public TdTagOpenContext tdTagOpen(int i) {
2425                        return getRuleContext(TdTagOpenContext.class,i);
2426                }
2427                public List<ThTagOpenContext> thTagOpen() {
2428                        return getRuleContexts(ThTagOpenContext.class);
2429                }
2430                public ThTagOpenContext thTagOpen(int i) {
2431                        return getRuleContext(ThTagOpenContext.class,i);
2432                }
2433                public List<BodyTagOpenContext> bodyTagOpen() {
2434                        return getRuleContexts(BodyTagOpenContext.class);
2435                }
2436                public BodyTagOpenContext bodyTagOpen(int i) {
2437                        return getRuleContext(BodyTagOpenContext.class,i);
2438                }
2439                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2440                        return getRuleContexts(ColgroupTagOpenContext.class);
2441                }
2442                public ColgroupTagOpenContext colgroupTagOpen(int i) {
2443                        return getRuleContext(ColgroupTagOpenContext.class,i);
2444                }
2445                public List<DdTagOpenContext> ddTagOpen() {
2446                        return getRuleContexts(DdTagOpenContext.class);
2447                }
2448                public DdTagOpenContext ddTagOpen(int i) {
2449                        return getRuleContext(DdTagOpenContext.class,i);
2450                }
2451                public List<DtTagOpenContext> dtTagOpen() {
2452                        return getRuleContexts(DtTagOpenContext.class);
2453                }
2454                public DtTagOpenContext dtTagOpen(int i) {
2455                        return getRuleContext(DtTagOpenContext.class,i);
2456                }
2457                public List<HeadTagOpenContext> headTagOpen() {
2458                        return getRuleContexts(HeadTagOpenContext.class);
2459                }
2460                public HeadTagOpenContext headTagOpen(int i) {
2461                        return getRuleContext(HeadTagOpenContext.class,i);
2462                }
2463                public List<HtmlTagOpenContext> htmlTagOpen() {
2464                        return getRuleContexts(HtmlTagOpenContext.class);
2465                }
2466                public HtmlTagOpenContext htmlTagOpen(int i) {
2467                        return getRuleContext(HtmlTagOpenContext.class,i);
2468                }
2469                public List<OptionTagOpenContext> optionTagOpen() {
2470                        return getRuleContexts(OptionTagOpenContext.class);
2471                }
2472                public OptionTagOpenContext optionTagOpen(int i) {
2473                        return getRuleContext(OptionTagOpenContext.class,i);
2474                }
2475                public List<TbodyTagOpenContext> tbodyTagOpen() {
2476                        return getRuleContexts(TbodyTagOpenContext.class);
2477                }
2478                public TbodyTagOpenContext tbodyTagOpen(int i) {
2479                        return getRuleContext(TbodyTagOpenContext.class,i);
2480                }
2481                public List<TheadTagOpenContext> theadTagOpen() {
2482                        return getRuleContexts(TheadTagOpenContext.class);
2483                }
2484                public TheadTagOpenContext theadTagOpen(int i) {
2485                        return getRuleContext(TheadTagOpenContext.class,i);
2486                }
2487                public List<TfootTagOpenContext> tfootTagOpen() {
2488                        return getRuleContexts(TfootTagOpenContext.class);
2489                }
2490                public TfootTagOpenContext tfootTagOpen(int i) {
2491                        return getRuleContext(TfootTagOpenContext.class,i);
2492                }
2493                public List<HtmlCommentContext> htmlComment() {
2494                        return getRuleContexts(HtmlCommentContext.class);
2495                }
2496                public HtmlCommentContext htmlComment(int i) {
2497                        return getRuleContext(HtmlCommentContext.class,i);
2498                }
2499                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2500                public TerminalNode CDATA(int i) {
2501                        return getToken(JavadocParser.CDATA, i);
2502                }
2503                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2504                public TerminalNode NEWLINE(int i) {
2505                        return getToken(JavadocParser.NEWLINE, i);
2506                }
2507                public List<TextContext> text() {
2508                        return getRuleContexts(TextContext.class);
2509                }
2510                public TextContext text(int i) {
2511                        return getRuleContext(TextContext.class,i);
2512                }
2513                public List<JavadocInlineTagContext> javadocInlineTag() {
2514                        return getRuleContexts(JavadocInlineTagContext.class);
2515                }
2516                public JavadocInlineTagContext javadocInlineTag(int i) {
2517                        return getRuleContext(JavadocInlineTagContext.class,i);
2518                }
2519                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2520                public TerminalNode LEADING_ASTERISK(int i) {
2521                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2522                }
2523                public LiContext(ParserRuleContext parent, int invokingState) {
2524                        super(parent, invokingState);
2525                }
2526                @Override public int getRuleIndex() { return RULE_li; }
2527                @Override
2528                public void enterRule(ParseTreeListener listener) {
2529                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this);
2530                }
2531                @Override
2532                public void exitRule(ParseTreeListener listener) {
2533                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this);
2534                }
2535                @Override
2536                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2537                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this);
2538                        else return visitor.visitChildren(this);
2539                }
2540        }
2541
2542        public final LiContext li() throws RecognitionException {
2543                LiContext _localctx = new LiContext(_ctx, getState());
2544                enterRule(_localctx, 22, RULE_li);
2545                try {
2546                        int _alt;
2547                        enterOuterAlt(_localctx, 1);
2548                        {
2549                        setState(399);
2550                        liTagOpen();
2551                        setState(439);
2552                        _errHandler.sync(this);
2553                        _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2554                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2555                                if ( _alt==1 ) {
2556                                        {
2557                                        setState(437);
2558                                        switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
2559                                        case 1:
2560                                                {
2561                                                setState(400);
2562                                                htmlTag();
2563                                                }
2564                                                break;
2565                                        case 2:
2566                                                {
2567                                                setState(401);
2568                                                singletonTag();
2569                                                }
2570                                                break;
2571                                        case 3:
2572                                                {
2573                                                setState(402);
2574                                                paragraph();
2575                                                }
2576                                                break;
2577                                        case 4:
2578                                                {
2579                                                setState(403);
2580                                                tr();
2581                                                }
2582                                                break;
2583                                        case 5:
2584                                                {
2585                                                setState(404);
2586                                                td();
2587                                                }
2588                                                break;
2589                                        case 6:
2590                                                {
2591                                                setState(405);
2592                                                th();
2593                                                }
2594                                                break;
2595                                        case 7:
2596                                                {
2597                                                setState(406);
2598                                                body();
2599                                                }
2600                                                break;
2601                                        case 8:
2602                                                {
2603                                                setState(407);
2604                                                colgroup();
2605                                                }
2606                                                break;
2607                                        case 9:
2608                                                {
2609                                                setState(408);
2610                                                dd();
2611                                                }
2612                                                break;
2613                                        case 10:
2614                                                {
2615                                                setState(409);
2616                                                dt();
2617                                                }
2618                                                break;
2619                                        case 11:
2620                                                {
2621                                                setState(410);
2622                                                head();
2623                                                }
2624                                                break;
2625                                        case 12:
2626                                                {
2627                                                setState(411);
2628                                                html();
2629                                                }
2630                                                break;
2631                                        case 13:
2632                                                {
2633                                                setState(412);
2634                                                option();
2635                                                }
2636                                                break;
2637                                        case 14:
2638                                                {
2639                                                setState(413);
2640                                                tbody();
2641                                                }
2642                                                break;
2643                                        case 15:
2644                                                {
2645                                                setState(414);
2646                                                thead();
2647                                                }
2648                                                break;
2649                                        case 16:
2650                                                {
2651                                                setState(415);
2652                                                tfoot();
2653                                                }
2654                                                break;
2655                                        case 17:
2656                                                {
2657                                                setState(416);
2658                                                pTagOpen();
2659                                                }
2660                                                break;
2661                                        case 18:
2662                                                {
2663                                                setState(417);
2664                                                trTagOpen();
2665                                                }
2666                                                break;
2667                                        case 19:
2668                                                {
2669                                                setState(418);
2670                                                tdTagOpen();
2671                                                }
2672                                                break;
2673                                        case 20:
2674                                                {
2675                                                setState(419);
2676                                                thTagOpen();
2677                                                }
2678                                                break;
2679                                        case 21:
2680                                                {
2681                                                setState(420);
2682                                                bodyTagOpen();
2683                                                }
2684                                                break;
2685                                        case 22:
2686                                                {
2687                                                setState(421);
2688                                                colgroupTagOpen();
2689                                                }
2690                                                break;
2691                                        case 23:
2692                                                {
2693                                                setState(422);
2694                                                ddTagOpen();
2695                                                }
2696                                                break;
2697                                        case 24:
2698                                                {
2699                                                setState(423);
2700                                                dtTagOpen();
2701                                                }
2702                                                break;
2703                                        case 25:
2704                                                {
2705                                                setState(424);
2706                                                headTagOpen();
2707                                                }
2708                                                break;
2709                                        case 26:
2710                                                {
2711                                                setState(425);
2712                                                htmlTagOpen();
2713                                                }
2714                                                break;
2715                                        case 27:
2716                                                {
2717                                                setState(426);
2718                                                optionTagOpen();
2719                                                }
2720                                                break;
2721                                        case 28:
2722                                                {
2723                                                setState(427);
2724                                                tbodyTagOpen();
2725                                                }
2726                                                break;
2727                                        case 29:
2728                                                {
2729                                                setState(428);
2730                                                theadTagOpen();
2731                                                }
2732                                                break;
2733                                        case 30:
2734                                                {
2735                                                setState(429);
2736                                                tfootTagOpen();
2737                                                }
2738                                                break;
2739                                        case 31:
2740                                                {
2741                                                {
2742                                                setState(430);
2743                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2744                                                setState(431);
2745                                                match(LEADING_ASTERISK);
2746                                                }
2747                                                }
2748                                                break;
2749                                        case 32:
2750                                                {
2751                                                setState(432);
2752                                                htmlComment();
2753                                                }
2754                                                break;
2755                                        case 33:
2756                                                {
2757                                                setState(433);
2758                                                match(CDATA);
2759                                                }
2760                                                break;
2761                                        case 34:
2762                                                {
2763                                                setState(434);
2764                                                match(NEWLINE);
2765                                                }
2766                                                break;
2767                                        case 35:
2768                                                {
2769                                                setState(435);
2770                                                text();
2771                                                }
2772                                                break;
2773                                        case 36:
2774                                                {
2775                                                setState(436);
2776                                                javadocInlineTag();
2777                                                }
2778                                                break;
2779                                        }
2780                                        } 
2781                                }
2782                                setState(441);
2783                                _errHandler.sync(this);
2784                                _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2785                        }
2786                        setState(442);
2787                        liTagClose();
2788                        }
2789                }
2790                catch (RecognitionException re) {
2791                        _localctx.exception = re;
2792                        _errHandler.reportError(this, re);
2793                        _errHandler.recover(this, re);
2794                }
2795                finally {
2796                        exitRule();
2797                }
2798                return _localctx;
2799        }
2800
2801        public static class TrTagOpenContext extends ParserRuleContext {
2802                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2803                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2804                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2805                public List<AttributeContext> attribute() {
2806                        return getRuleContexts(AttributeContext.class);
2807                }
2808                public AttributeContext attribute(int i) {
2809                        return getRuleContext(AttributeContext.class,i);
2810                }
2811                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2812                public TerminalNode NEWLINE(int i) {
2813                        return getToken(JavadocParser.NEWLINE, i);
2814                }
2815                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2816                public TerminalNode LEADING_ASTERISK(int i) {
2817                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2818                }
2819                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2820                public TerminalNode WS(int i) {
2821                        return getToken(JavadocParser.WS, i);
2822                }
2823                public TrTagOpenContext(ParserRuleContext parent, int invokingState) {
2824                        super(parent, invokingState);
2825                }
2826                @Override public int getRuleIndex() { return RULE_trTagOpen; }
2827                @Override
2828                public void enterRule(ParseTreeListener listener) {
2829                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this);
2830                }
2831                @Override
2832                public void exitRule(ParseTreeListener listener) {
2833                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this);
2834                }
2835                @Override
2836                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2837                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this);
2838                        else return visitor.visitChildren(this);
2839                }
2840        }
2841
2842        public final TrTagOpenContext trTagOpen() throws RecognitionException {
2843                TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState());
2844                enterRule(_localctx, 24, RULE_trTagOpen);
2845                int _la;
2846                try {
2847                        enterOuterAlt(_localctx, 1);
2848                        {
2849                        setState(444);
2850                        match(OPEN);
2851                        setState(445);
2852                        match(TR_HTML_TAG_NAME);
2853                        setState(452);
2854                        _errHandler.sync(this);
2855                        _la = _input.LA(1);
2856                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2857                                {
2858                                setState(450);
2859                                switch (_input.LA(1)) {
2860                                case HTML_TAG_NAME:
2861                                        {
2862                                        setState(446);
2863                                        attribute();
2864                                        }
2865                                        break;
2866                                case NEWLINE:
2867                                        {
2868                                        setState(447);
2869                                        match(NEWLINE);
2870                                        }
2871                                        break;
2872                                case LEADING_ASTERISK:
2873                                        {
2874                                        setState(448);
2875                                        match(LEADING_ASTERISK);
2876                                        }
2877                                        break;
2878                                case WS:
2879                                        {
2880                                        setState(449);
2881                                        match(WS);
2882                                        }
2883                                        break;
2884                                default:
2885                                        throw new NoViableAltException(this);
2886                                }
2887                                }
2888                                setState(454);
2889                                _errHandler.sync(this);
2890                                _la = _input.LA(1);
2891                        }
2892                        setState(455);
2893                        match(CLOSE);
2894                        }
2895                }
2896                catch (RecognitionException re) {
2897                        _localctx.exception = re;
2898                        _errHandler.reportError(this, re);
2899                        _errHandler.recover(this, re);
2900                }
2901                finally {
2902                        exitRule();
2903                }
2904                return _localctx;
2905        }
2906
2907        public static class TrTagCloseContext extends ParserRuleContext {
2908                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2909                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2910                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2911                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2912                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2913                public TerminalNode NEWLINE(int i) {
2914                        return getToken(JavadocParser.NEWLINE, i);
2915                }
2916                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2917                public TerminalNode LEADING_ASTERISK(int i) {
2918                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2919                }
2920                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2921                public TerminalNode WS(int i) {
2922                        return getToken(JavadocParser.WS, i);
2923                }
2924                public TrTagCloseContext(ParserRuleContext parent, int invokingState) {
2925                        super(parent, invokingState);
2926                }
2927                @Override public int getRuleIndex() { return RULE_trTagClose; }
2928                @Override
2929                public void enterRule(ParseTreeListener listener) {
2930                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this);
2931                }
2932                @Override
2933                public void exitRule(ParseTreeListener listener) {
2934                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this);
2935                }
2936                @Override
2937                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2938                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this);
2939                        else return visitor.visitChildren(this);
2940                }
2941        }
2942
2943        public final TrTagCloseContext trTagClose() throws RecognitionException {
2944                TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState());
2945                enterRule(_localctx, 26, RULE_trTagClose);
2946                int _la;
2947                try {
2948                        enterOuterAlt(_localctx, 1);
2949                        {
2950                        setState(457);
2951                        match(OPEN);
2952                        setState(458);
2953                        match(SLASH);
2954                        setState(459);
2955                        match(TR_HTML_TAG_NAME);
2956                        setState(463);
2957                        _errHandler.sync(this);
2958                        _la = _input.LA(1);
2959                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2960                                {
2961                                {
2962                                setState(460);
2963                                _la = _input.LA(1);
2964                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2965                                _errHandler.recoverInline(this);
2966                                } else {
2967                                        consume();
2968                                }
2969                                }
2970                                }
2971                                setState(465);
2972                                _errHandler.sync(this);
2973                                _la = _input.LA(1);
2974                        }
2975                        setState(466);
2976                        match(CLOSE);
2977                        }
2978                }
2979                catch (RecognitionException re) {
2980                        _localctx.exception = re;
2981                        _errHandler.reportError(this, re);
2982                        _errHandler.recover(this, re);
2983                }
2984                finally {
2985                        exitRule();
2986                }
2987                return _localctx;
2988        }
2989
2990        public static class TrContext extends ParserRuleContext {
2991                public TrTagOpenContext trTagOpen() {
2992                        return getRuleContext(TrTagOpenContext.class,0);
2993                }
2994                public TrTagCloseContext trTagClose() {
2995                        return getRuleContext(TrTagCloseContext.class,0);
2996                }
2997                public List<HtmlTagContext> htmlTag() {
2998                        return getRuleContexts(HtmlTagContext.class);
2999                }
3000                public HtmlTagContext htmlTag(int i) {
3001                        return getRuleContext(HtmlTagContext.class,i);
3002                }
3003                public List<SingletonTagContext> singletonTag() {
3004                        return getRuleContexts(SingletonTagContext.class);
3005                }
3006                public SingletonTagContext singletonTag(int i) {
3007                        return getRuleContext(SingletonTagContext.class,i);
3008                }
3009                public List<ParagraphContext> paragraph() {
3010                        return getRuleContexts(ParagraphContext.class);
3011                }
3012                public ParagraphContext paragraph(int i) {
3013                        return getRuleContext(ParagraphContext.class,i);
3014                }
3015                public List<LiContext> li() {
3016                        return getRuleContexts(LiContext.class);
3017                }
3018                public LiContext li(int i) {
3019                        return getRuleContext(LiContext.class,i);
3020                }
3021                public List<TdContext> td() {
3022                        return getRuleContexts(TdContext.class);
3023                }
3024                public TdContext td(int i) {
3025                        return getRuleContext(TdContext.class,i);
3026                }
3027                public List<ThContext> th() {
3028                        return getRuleContexts(ThContext.class);
3029                }
3030                public ThContext th(int i) {
3031                        return getRuleContext(ThContext.class,i);
3032                }
3033                public List<BodyContext> body() {
3034                        return getRuleContexts(BodyContext.class);
3035                }
3036                public BodyContext body(int i) {
3037                        return getRuleContext(BodyContext.class,i);
3038                }
3039                public List<ColgroupContext> colgroup() {
3040                        return getRuleContexts(ColgroupContext.class);
3041                }
3042                public ColgroupContext colgroup(int i) {
3043                        return getRuleContext(ColgroupContext.class,i);
3044                }
3045                public List<DdContext> dd() {
3046                        return getRuleContexts(DdContext.class);
3047                }
3048                public DdContext dd(int i) {
3049                        return getRuleContext(DdContext.class,i);
3050                }
3051                public List<DtContext> dt() {
3052                        return getRuleContexts(DtContext.class);
3053                }
3054                public DtContext dt(int i) {
3055                        return getRuleContext(DtContext.class,i);
3056                }
3057                public List<HeadContext> head() {
3058                        return getRuleContexts(HeadContext.class);
3059                }
3060                public HeadContext head(int i) {
3061                        return getRuleContext(HeadContext.class,i);
3062                }
3063                public List<HtmlContext> html() {
3064                        return getRuleContexts(HtmlContext.class);
3065                }
3066                public HtmlContext html(int i) {
3067                        return getRuleContext(HtmlContext.class,i);
3068                }
3069                public List<OptionContext> option() {
3070                        return getRuleContexts(OptionContext.class);
3071                }
3072                public OptionContext option(int i) {
3073                        return getRuleContext(OptionContext.class,i);
3074                }
3075                public List<TbodyContext> tbody() {
3076                        return getRuleContexts(TbodyContext.class);
3077                }
3078                public TbodyContext tbody(int i) {
3079                        return getRuleContext(TbodyContext.class,i);
3080                }
3081                public List<TheadContext> thead() {
3082                        return getRuleContexts(TheadContext.class);
3083                }
3084                public TheadContext thead(int i) {
3085                        return getRuleContext(TheadContext.class,i);
3086                }
3087                public List<TfootContext> tfoot() {
3088                        return getRuleContexts(TfootContext.class);
3089                }
3090                public TfootContext tfoot(int i) {
3091                        return getRuleContext(TfootContext.class,i);
3092                }
3093                public List<PTagOpenContext> pTagOpen() {
3094                        return getRuleContexts(PTagOpenContext.class);
3095                }
3096                public PTagOpenContext pTagOpen(int i) {
3097                        return getRuleContext(PTagOpenContext.class,i);
3098                }
3099                public List<LiTagOpenContext> liTagOpen() {
3100                        return getRuleContexts(LiTagOpenContext.class);
3101                }
3102                public LiTagOpenContext liTagOpen(int i) {
3103                        return getRuleContext(LiTagOpenContext.class,i);
3104                }
3105                public List<TdTagOpenContext> tdTagOpen() {
3106                        return getRuleContexts(TdTagOpenContext.class);
3107                }
3108                public TdTagOpenContext tdTagOpen(int i) {
3109                        return getRuleContext(TdTagOpenContext.class,i);
3110                }
3111                public List<ThTagOpenContext> thTagOpen() {
3112                        return getRuleContexts(ThTagOpenContext.class);
3113                }
3114                public ThTagOpenContext thTagOpen(int i) {
3115                        return getRuleContext(ThTagOpenContext.class,i);
3116                }
3117                public List<BodyTagOpenContext> bodyTagOpen() {
3118                        return getRuleContexts(BodyTagOpenContext.class);
3119                }
3120                public BodyTagOpenContext bodyTagOpen(int i) {
3121                        return getRuleContext(BodyTagOpenContext.class,i);
3122                }
3123                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3124                        return getRuleContexts(ColgroupTagOpenContext.class);
3125                }
3126                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3127                        return getRuleContext(ColgroupTagOpenContext.class,i);
3128                }
3129                public List<DdTagOpenContext> ddTagOpen() {
3130                        return getRuleContexts(DdTagOpenContext.class);
3131                }
3132                public DdTagOpenContext ddTagOpen(int i) {
3133                        return getRuleContext(DdTagOpenContext.class,i);
3134                }
3135                public List<DtTagOpenContext> dtTagOpen() {
3136                        return getRuleContexts(DtTagOpenContext.class);
3137                }
3138                public DtTagOpenContext dtTagOpen(int i) {
3139                        return getRuleContext(DtTagOpenContext.class,i);
3140                }
3141                public List<HeadTagOpenContext> headTagOpen() {
3142                        return getRuleContexts(HeadTagOpenContext.class);
3143                }
3144                public HeadTagOpenContext headTagOpen(int i) {
3145                        return getRuleContext(HeadTagOpenContext.class,i);
3146                }
3147                public List<HtmlTagOpenContext> htmlTagOpen() {
3148                        return getRuleContexts(HtmlTagOpenContext.class);
3149                }
3150                public HtmlTagOpenContext htmlTagOpen(int i) {
3151                        return getRuleContext(HtmlTagOpenContext.class,i);
3152                }
3153                public List<OptionTagOpenContext> optionTagOpen() {
3154                        return getRuleContexts(OptionTagOpenContext.class);
3155                }
3156                public OptionTagOpenContext optionTagOpen(int i) {
3157                        return getRuleContext(OptionTagOpenContext.class,i);
3158                }
3159                public List<TbodyTagOpenContext> tbodyTagOpen() {
3160                        return getRuleContexts(TbodyTagOpenContext.class);
3161                }
3162                public TbodyTagOpenContext tbodyTagOpen(int i) {
3163                        return getRuleContext(TbodyTagOpenContext.class,i);
3164                }
3165                public List<TheadTagOpenContext> theadTagOpen() {
3166                        return getRuleContexts(TheadTagOpenContext.class);
3167                }
3168                public TheadTagOpenContext theadTagOpen(int i) {
3169                        return getRuleContext(TheadTagOpenContext.class,i);
3170                }
3171                public List<TfootTagOpenContext> tfootTagOpen() {
3172                        return getRuleContexts(TfootTagOpenContext.class);
3173                }
3174                public TfootTagOpenContext tfootTagOpen(int i) {
3175                        return getRuleContext(TfootTagOpenContext.class,i);
3176                }
3177                public List<HtmlCommentContext> htmlComment() {
3178                        return getRuleContexts(HtmlCommentContext.class);
3179                }
3180                public HtmlCommentContext htmlComment(int i) {
3181                        return getRuleContext(HtmlCommentContext.class,i);
3182                }
3183                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3184                public TerminalNode CDATA(int i) {
3185                        return getToken(JavadocParser.CDATA, i);
3186                }
3187                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3188                public TerminalNode NEWLINE(int i) {
3189                        return getToken(JavadocParser.NEWLINE, i);
3190                }
3191                public List<TextContext> text() {
3192                        return getRuleContexts(TextContext.class);
3193                }
3194                public TextContext text(int i) {
3195                        return getRuleContext(TextContext.class,i);
3196                }
3197                public List<JavadocInlineTagContext> javadocInlineTag() {
3198                        return getRuleContexts(JavadocInlineTagContext.class);
3199                }
3200                public JavadocInlineTagContext javadocInlineTag(int i) {
3201                        return getRuleContext(JavadocInlineTagContext.class,i);
3202                }
3203                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3204                public TerminalNode LEADING_ASTERISK(int i) {
3205                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3206                }
3207                public TrContext(ParserRuleContext parent, int invokingState) {
3208                        super(parent, invokingState);
3209                }
3210                @Override public int getRuleIndex() { return RULE_tr; }
3211                @Override
3212                public void enterRule(ParseTreeListener listener) {
3213                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this);
3214                }
3215                @Override
3216                public void exitRule(ParseTreeListener listener) {
3217                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this);
3218                }
3219                @Override
3220                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3221                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this);
3222                        else return visitor.visitChildren(this);
3223                }
3224        }
3225
3226        public final TrContext tr() throws RecognitionException {
3227                TrContext _localctx = new TrContext(_ctx, getState());
3228                enterRule(_localctx, 28, RULE_tr);
3229                try {
3230                        int _alt;
3231                        enterOuterAlt(_localctx, 1);
3232                        {
3233                        setState(468);
3234                        trTagOpen();
3235                        setState(508);
3236                        _errHandler.sync(this);
3237                        _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3238                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3239                                if ( _alt==1 ) {
3240                                        {
3241                                        setState(506);
3242                                        switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
3243                                        case 1:
3244                                                {
3245                                                setState(469);
3246                                                htmlTag();
3247                                                }
3248                                                break;
3249                                        case 2:
3250                                                {
3251                                                setState(470);
3252                                                singletonTag();
3253                                                }
3254                                                break;
3255                                        case 3:
3256                                                {
3257                                                setState(471);
3258                                                paragraph();
3259                                                }
3260                                                break;
3261                                        case 4:
3262                                                {
3263                                                setState(472);
3264                                                li();
3265                                                }
3266                                                break;
3267                                        case 5:
3268                                                {
3269                                                setState(473);
3270                                                td();
3271                                                }
3272                                                break;
3273                                        case 6:
3274                                                {
3275                                                setState(474);
3276                                                th();
3277                                                }
3278                                                break;
3279                                        case 7:
3280                                                {
3281                                                setState(475);
3282                                                body();
3283                                                }
3284                                                break;
3285                                        case 8:
3286                                                {
3287                                                setState(476);
3288                                                colgroup();
3289                                                }
3290                                                break;
3291                                        case 9:
3292                                                {
3293                                                setState(477);
3294                                                dd();
3295                                                }
3296                                                break;
3297                                        case 10:
3298                                                {
3299                                                setState(478);
3300                                                dt();
3301                                                }
3302                                                break;
3303                                        case 11:
3304                                                {
3305                                                setState(479);
3306                                                head();
3307                                                }
3308                                                break;
3309                                        case 12:
3310                                                {
3311                                                setState(480);
3312                                                html();
3313                                                }
3314                                                break;
3315                                        case 13:
3316                                                {
3317                                                setState(481);
3318                                                option();
3319                                                }
3320                                                break;
3321                                        case 14:
3322                                                {
3323                                                setState(482);
3324                                                tbody();
3325                                                }
3326                                                break;
3327                                        case 15:
3328                                                {
3329                                                setState(483);
3330                                                thead();
3331                                                }
3332                                                break;
3333                                        case 16:
3334                                                {
3335                                                setState(484);
3336                                                tfoot();
3337                                                }
3338                                                break;
3339                                        case 17:
3340                                                {
3341                                                setState(485);
3342                                                pTagOpen();
3343                                                }
3344                                                break;
3345                                        case 18:
3346                                                {
3347                                                setState(486);
3348                                                liTagOpen();
3349                                                }
3350                                                break;
3351                                        case 19:
3352                                                {
3353                                                setState(487);
3354                                                tdTagOpen();
3355                                                }
3356                                                break;
3357                                        case 20:
3358                                                {
3359                                                setState(488);
3360                                                thTagOpen();
3361                                                }
3362                                                break;
3363                                        case 21:
3364                                                {
3365                                                setState(489);
3366                                                bodyTagOpen();
3367                                                }
3368                                                break;
3369                                        case 22:
3370                                                {
3371                                                setState(490);
3372                                                colgroupTagOpen();
3373                                                }
3374                                                break;
3375                                        case 23:
3376                                                {
3377                                                setState(491);
3378                                                ddTagOpen();
3379                                                }
3380                                                break;
3381                                        case 24:
3382                                                {
3383                                                setState(492);
3384                                                dtTagOpen();
3385                                                }
3386                                                break;
3387                                        case 25:
3388                                                {
3389                                                setState(493);
3390                                                headTagOpen();
3391                                                }
3392                                                break;
3393                                        case 26:
3394                                                {
3395                                                setState(494);
3396                                                htmlTagOpen();
3397                                                }
3398                                                break;
3399                                        case 27:
3400                                                {
3401                                                setState(495);
3402                                                optionTagOpen();
3403                                                }
3404                                                break;
3405                                        case 28:
3406                                                {
3407                                                setState(496);
3408                                                tbodyTagOpen();
3409                                                }
3410                                                break;
3411                                        case 29:
3412                                                {
3413                                                setState(497);
3414                                                theadTagOpen();
3415                                                }
3416                                                break;
3417                                        case 30:
3418                                                {
3419                                                setState(498);
3420                                                tfootTagOpen();
3421                                                }
3422                                                break;
3423                                        case 31:
3424                                                {
3425                                                {
3426                                                setState(499);
3427                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3428                                                setState(500);
3429                                                match(LEADING_ASTERISK);
3430                                                }
3431                                                }
3432                                                break;
3433                                        case 32:
3434                                                {
3435                                                setState(501);
3436                                                htmlComment();
3437                                                }
3438                                                break;
3439                                        case 33:
3440                                                {
3441                                                setState(502);
3442                                                match(CDATA);
3443                                                }
3444                                                break;
3445                                        case 34:
3446                                                {
3447                                                setState(503);
3448                                                match(NEWLINE);
3449                                                }
3450                                                break;
3451                                        case 35:
3452                                                {
3453                                                setState(504);
3454                                                text();
3455                                                }
3456                                                break;
3457                                        case 36:
3458                                                {
3459                                                setState(505);
3460                                                javadocInlineTag();
3461                                                }
3462                                                break;
3463                                        }
3464                                        } 
3465                                }
3466                                setState(510);
3467                                _errHandler.sync(this);
3468                                _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3469                        }
3470                        setState(511);
3471                        trTagClose();
3472                        }
3473                }
3474                catch (RecognitionException re) {
3475                        _localctx.exception = re;
3476                        _errHandler.reportError(this, re);
3477                        _errHandler.recover(this, re);
3478                }
3479                finally {
3480                        exitRule();
3481                }
3482                return _localctx;
3483        }
3484
3485        public static class TdTagOpenContext extends ParserRuleContext {
3486                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3487                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3488                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3489                public List<AttributeContext> attribute() {
3490                        return getRuleContexts(AttributeContext.class);
3491                }
3492                public AttributeContext attribute(int i) {
3493                        return getRuleContext(AttributeContext.class,i);
3494                }
3495                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3496                public TerminalNode NEWLINE(int i) {
3497                        return getToken(JavadocParser.NEWLINE, i);
3498                }
3499                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3500                public TerminalNode LEADING_ASTERISK(int i) {
3501                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3502                }
3503                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3504                public TerminalNode WS(int i) {
3505                        return getToken(JavadocParser.WS, i);
3506                }
3507                public TdTagOpenContext(ParserRuleContext parent, int invokingState) {
3508                        super(parent, invokingState);
3509                }
3510                @Override public int getRuleIndex() { return RULE_tdTagOpen; }
3511                @Override
3512                public void enterRule(ParseTreeListener listener) {
3513                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this);
3514                }
3515                @Override
3516                public void exitRule(ParseTreeListener listener) {
3517                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this);
3518                }
3519                @Override
3520                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3521                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this);
3522                        else return visitor.visitChildren(this);
3523                }
3524        }
3525
3526        public final TdTagOpenContext tdTagOpen() throws RecognitionException {
3527                TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState());
3528                enterRule(_localctx, 30, RULE_tdTagOpen);
3529                int _la;
3530                try {
3531                        enterOuterAlt(_localctx, 1);
3532                        {
3533                        setState(513);
3534                        match(OPEN);
3535                        setState(514);
3536                        match(TD_HTML_TAG_NAME);
3537                        setState(521);
3538                        _errHandler.sync(this);
3539                        _la = _input.LA(1);
3540                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3541                                {
3542                                setState(519);
3543                                switch (_input.LA(1)) {
3544                                case HTML_TAG_NAME:
3545                                        {
3546                                        setState(515);
3547                                        attribute();
3548                                        }
3549                                        break;
3550                                case NEWLINE:
3551                                        {
3552                                        setState(516);
3553                                        match(NEWLINE);
3554                                        }
3555                                        break;
3556                                case LEADING_ASTERISK:
3557                                        {
3558                                        setState(517);
3559                                        match(LEADING_ASTERISK);
3560                                        }
3561                                        break;
3562                                case WS:
3563                                        {
3564                                        setState(518);
3565                                        match(WS);
3566                                        }
3567                                        break;
3568                                default:
3569                                        throw new NoViableAltException(this);
3570                                }
3571                                }
3572                                setState(523);
3573                                _errHandler.sync(this);
3574                                _la = _input.LA(1);
3575                        }
3576                        setState(524);
3577                        match(CLOSE);
3578                        }
3579                }
3580                catch (RecognitionException re) {
3581                        _localctx.exception = re;
3582                        _errHandler.reportError(this, re);
3583                        _errHandler.recover(this, re);
3584                }
3585                finally {
3586                        exitRule();
3587                }
3588                return _localctx;
3589        }
3590
3591        public static class TdTagCloseContext extends ParserRuleContext {
3592                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3593                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3594                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3595                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3596                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3597                public TerminalNode NEWLINE(int i) {
3598                        return getToken(JavadocParser.NEWLINE, i);
3599                }
3600                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3601                public TerminalNode LEADING_ASTERISK(int i) {
3602                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3603                }
3604                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3605                public TerminalNode WS(int i) {
3606                        return getToken(JavadocParser.WS, i);
3607                }
3608                public TdTagCloseContext(ParserRuleContext parent, int invokingState) {
3609                        super(parent, invokingState);
3610                }
3611                @Override public int getRuleIndex() { return RULE_tdTagClose; }
3612                @Override
3613                public void enterRule(ParseTreeListener listener) {
3614                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this);
3615                }
3616                @Override
3617                public void exitRule(ParseTreeListener listener) {
3618                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this);
3619                }
3620                @Override
3621                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3622                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this);
3623                        else return visitor.visitChildren(this);
3624                }
3625        }
3626
3627        public final TdTagCloseContext tdTagClose() throws RecognitionException {
3628                TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState());
3629                enterRule(_localctx, 32, RULE_tdTagClose);
3630                int _la;
3631                try {
3632                        enterOuterAlt(_localctx, 1);
3633                        {
3634                        setState(526);
3635                        match(OPEN);
3636                        setState(527);
3637                        match(SLASH);
3638                        setState(528);
3639                        match(TD_HTML_TAG_NAME);
3640                        setState(532);
3641                        _errHandler.sync(this);
3642                        _la = _input.LA(1);
3643                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3644                                {
3645                                {
3646                                setState(529);
3647                                _la = _input.LA(1);
3648                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3649                                _errHandler.recoverInline(this);
3650                                } else {
3651                                        consume();
3652                                }
3653                                }
3654                                }
3655                                setState(534);
3656                                _errHandler.sync(this);
3657                                _la = _input.LA(1);
3658                        }
3659                        setState(535);
3660                        match(CLOSE);
3661                        }
3662                }
3663                catch (RecognitionException re) {
3664                        _localctx.exception = re;
3665                        _errHandler.reportError(this, re);
3666                        _errHandler.recover(this, re);
3667                }
3668                finally {
3669                        exitRule();
3670                }
3671                return _localctx;
3672        }
3673
3674        public static class TdContext extends ParserRuleContext {
3675                public List<TdTagOpenContext> tdTagOpen() {
3676                        return getRuleContexts(TdTagOpenContext.class);
3677                }
3678                public TdTagOpenContext tdTagOpen(int i) {
3679                        return getRuleContext(TdTagOpenContext.class,i);
3680                }
3681                public TdTagCloseContext tdTagClose() {
3682                        return getRuleContext(TdTagCloseContext.class,0);
3683                }
3684                public List<HtmlTagContext> htmlTag() {
3685                        return getRuleContexts(HtmlTagContext.class);
3686                }
3687                public HtmlTagContext htmlTag(int i) {
3688                        return getRuleContext(HtmlTagContext.class,i);
3689                }
3690                public List<SingletonTagContext> singletonTag() {
3691                        return getRuleContexts(SingletonTagContext.class);
3692                }
3693                public SingletonTagContext singletonTag(int i) {
3694                        return getRuleContext(SingletonTagContext.class,i);
3695                }
3696                public List<ParagraphContext> paragraph() {
3697                        return getRuleContexts(ParagraphContext.class);
3698                }
3699                public ParagraphContext paragraph(int i) {
3700                        return getRuleContext(ParagraphContext.class,i);
3701                }
3702                public List<LiContext> li() {
3703                        return getRuleContexts(LiContext.class);
3704                }
3705                public LiContext li(int i) {
3706                        return getRuleContext(LiContext.class,i);
3707                }
3708                public List<TrContext> tr() {
3709                        return getRuleContexts(TrContext.class);
3710                }
3711                public TrContext tr(int i) {
3712                        return getRuleContext(TrContext.class,i);
3713                }
3714                public List<ThContext> th() {
3715                        return getRuleContexts(ThContext.class);
3716                }
3717                public ThContext th(int i) {
3718                        return getRuleContext(ThContext.class,i);
3719                }
3720                public List<BodyContext> body() {
3721                        return getRuleContexts(BodyContext.class);
3722                }
3723                public BodyContext body(int i) {
3724                        return getRuleContext(BodyContext.class,i);
3725                }
3726                public List<ColgroupContext> colgroup() {
3727                        return getRuleContexts(ColgroupContext.class);
3728                }
3729                public ColgroupContext colgroup(int i) {
3730                        return getRuleContext(ColgroupContext.class,i);
3731                }
3732                public List<DdContext> dd() {
3733                        return getRuleContexts(DdContext.class);
3734                }
3735                public DdContext dd(int i) {
3736                        return getRuleContext(DdContext.class,i);
3737                }
3738                public List<DtContext> dt() {
3739                        return getRuleContexts(DtContext.class);
3740                }
3741                public DtContext dt(int i) {
3742                        return getRuleContext(DtContext.class,i);
3743                }
3744                public List<HeadContext> head() {
3745                        return getRuleContexts(HeadContext.class);
3746                }
3747                public HeadContext head(int i) {
3748                        return getRuleContext(HeadContext.class,i);
3749                }
3750                public List<HtmlContext> html() {
3751                        return getRuleContexts(HtmlContext.class);
3752                }
3753                public HtmlContext html(int i) {
3754                        return getRuleContext(HtmlContext.class,i);
3755                }
3756                public List<OptionContext> option() {
3757                        return getRuleContexts(OptionContext.class);
3758                }
3759                public OptionContext option(int i) {
3760                        return getRuleContext(OptionContext.class,i);
3761                }
3762                public List<TbodyContext> tbody() {
3763                        return getRuleContexts(TbodyContext.class);
3764                }
3765                public TbodyContext tbody(int i) {
3766                        return getRuleContext(TbodyContext.class,i);
3767                }
3768                public List<TheadContext> thead() {
3769                        return getRuleContexts(TheadContext.class);
3770                }
3771                public TheadContext thead(int i) {
3772                        return getRuleContext(TheadContext.class,i);
3773                }
3774                public List<TfootContext> tfoot() {
3775                        return getRuleContexts(TfootContext.class);
3776                }
3777                public TfootContext tfoot(int i) {
3778                        return getRuleContext(TfootContext.class,i);
3779                }
3780                public List<PTagOpenContext> pTagOpen() {
3781                        return getRuleContexts(PTagOpenContext.class);
3782                }
3783                public PTagOpenContext pTagOpen(int i) {
3784                        return getRuleContext(PTagOpenContext.class,i);
3785                }
3786                public List<LiTagOpenContext> liTagOpen() {
3787                        return getRuleContexts(LiTagOpenContext.class);
3788                }
3789                public LiTagOpenContext liTagOpen(int i) {
3790                        return getRuleContext(LiTagOpenContext.class,i);
3791                }
3792                public List<ThTagOpenContext> thTagOpen() {
3793                        return getRuleContexts(ThTagOpenContext.class);
3794                }
3795                public ThTagOpenContext thTagOpen(int i) {
3796                        return getRuleContext(ThTagOpenContext.class,i);
3797                }
3798                public List<BodyTagOpenContext> bodyTagOpen() {
3799                        return getRuleContexts(BodyTagOpenContext.class);
3800                }
3801                public BodyTagOpenContext bodyTagOpen(int i) {
3802                        return getRuleContext(BodyTagOpenContext.class,i);
3803                }
3804                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3805                        return getRuleContexts(ColgroupTagOpenContext.class);
3806                }
3807                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3808                        return getRuleContext(ColgroupTagOpenContext.class,i);
3809                }
3810                public List<DdTagOpenContext> ddTagOpen() {
3811                        return getRuleContexts(DdTagOpenContext.class);
3812                }
3813                public DdTagOpenContext ddTagOpen(int i) {
3814                        return getRuleContext(DdTagOpenContext.class,i);
3815                }
3816                public List<DtTagOpenContext> dtTagOpen() {
3817                        return getRuleContexts(DtTagOpenContext.class);
3818                }
3819                public DtTagOpenContext dtTagOpen(int i) {
3820                        return getRuleContext(DtTagOpenContext.class,i);
3821                }
3822                public List<HeadTagOpenContext> headTagOpen() {
3823                        return getRuleContexts(HeadTagOpenContext.class);
3824                }
3825                public HeadTagOpenContext headTagOpen(int i) {
3826                        return getRuleContext(HeadTagOpenContext.class,i);
3827                }
3828                public List<HtmlTagOpenContext> htmlTagOpen() {
3829                        return getRuleContexts(HtmlTagOpenContext.class);
3830                }
3831                public HtmlTagOpenContext htmlTagOpen(int i) {
3832                        return getRuleContext(HtmlTagOpenContext.class,i);
3833                }
3834                public List<OptionTagOpenContext> optionTagOpen() {
3835                        return getRuleContexts(OptionTagOpenContext.class);
3836                }
3837                public OptionTagOpenContext optionTagOpen(int i) {
3838                        return getRuleContext(OptionTagOpenContext.class,i);
3839                }
3840                public List<TbodyTagOpenContext> tbodyTagOpen() {
3841                        return getRuleContexts(TbodyTagOpenContext.class);
3842                }
3843                public TbodyTagOpenContext tbodyTagOpen(int i) {
3844                        return getRuleContext(TbodyTagOpenContext.class,i);
3845                }
3846                public List<TheadTagOpenContext> theadTagOpen() {
3847                        return getRuleContexts(TheadTagOpenContext.class);
3848                }
3849                public TheadTagOpenContext theadTagOpen(int i) {
3850                        return getRuleContext(TheadTagOpenContext.class,i);
3851                }
3852                public List<TfootTagOpenContext> tfootTagOpen() {
3853                        return getRuleContexts(TfootTagOpenContext.class);
3854                }
3855                public TfootTagOpenContext tfootTagOpen(int i) {
3856                        return getRuleContext(TfootTagOpenContext.class,i);
3857                }
3858                public List<HtmlCommentContext> htmlComment() {
3859                        return getRuleContexts(HtmlCommentContext.class);
3860                }
3861                public HtmlCommentContext htmlComment(int i) {
3862                        return getRuleContext(HtmlCommentContext.class,i);
3863                }
3864                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3865                public TerminalNode CDATA(int i) {
3866                        return getToken(JavadocParser.CDATA, i);
3867                }
3868                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3869                public TerminalNode NEWLINE(int i) {
3870                        return getToken(JavadocParser.NEWLINE, i);
3871                }
3872                public List<TextContext> text() {
3873                        return getRuleContexts(TextContext.class);
3874                }
3875                public TextContext text(int i) {
3876                        return getRuleContext(TextContext.class,i);
3877                }
3878                public List<JavadocInlineTagContext> javadocInlineTag() {
3879                        return getRuleContexts(JavadocInlineTagContext.class);
3880                }
3881                public JavadocInlineTagContext javadocInlineTag(int i) {
3882                        return getRuleContext(JavadocInlineTagContext.class,i);
3883                }
3884                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3885                public TerminalNode LEADING_ASTERISK(int i) {
3886                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3887                }
3888                public TdContext(ParserRuleContext parent, int invokingState) {
3889                        super(parent, invokingState);
3890                }
3891                @Override public int getRuleIndex() { return RULE_td; }
3892                @Override
3893                public void enterRule(ParseTreeListener listener) {
3894                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this);
3895                }
3896                @Override
3897                public void exitRule(ParseTreeListener listener) {
3898                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this);
3899                }
3900                @Override
3901                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3902                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this);
3903                        else return visitor.visitChildren(this);
3904                }
3905        }
3906
3907        public final TdContext td() throws RecognitionException {
3908                TdContext _localctx = new TdContext(_ctx, getState());
3909                enterRule(_localctx, 34, RULE_td);
3910                try {
3911                        int _alt;
3912                        enterOuterAlt(_localctx, 1);
3913                        {
3914                        setState(537);
3915                        tdTagOpen();
3916                        setState(577);
3917                        _errHandler.sync(this);
3918                        _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
3919                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3920                                if ( _alt==1 ) {
3921                                        {
3922                                        setState(575);
3923                                        switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
3924                                        case 1:
3925                                                {
3926                                                setState(538);
3927                                                htmlTag();
3928                                                }
3929                                                break;
3930                                        case 2:
3931                                                {
3932                                                setState(539);
3933                                                singletonTag();
3934                                                }
3935                                                break;
3936                                        case 3:
3937                                                {
3938                                                setState(540);
3939                                                paragraph();
3940                                                }
3941                                                break;
3942                                        case 4:
3943                                                {
3944                                                setState(541);
3945                                                li();
3946                                                }
3947                                                break;
3948                                        case 5:
3949                                                {
3950                                                setState(542);
3951                                                tr();
3952                                                }
3953                                                break;
3954                                        case 6:
3955                                                {
3956                                                setState(543);
3957                                                th();
3958                                                }
3959                                                break;
3960                                        case 7:
3961                                                {
3962                                                setState(544);
3963                                                body();
3964                                                }
3965                                                break;
3966                                        case 8:
3967                                                {
3968                                                setState(545);
3969                                                colgroup();
3970                                                }
3971                                                break;
3972                                        case 9:
3973                                                {
3974                                                setState(546);
3975                                                dd();
3976                                                }
3977                                                break;
3978                                        case 10:
3979                                                {
3980                                                setState(547);
3981                                                dt();
3982                                                }
3983                                                break;
3984                                        case 11:
3985                                                {
3986                                                setState(548);
3987                                                head();
3988                                                }
3989                                                break;
3990                                        case 12:
3991                                                {
3992                                                setState(549);
3993                                                html();
3994                                                }
3995                                                break;
3996                                        case 13:
3997                                                {
3998                                                setState(550);
3999                                                option();
4000                                                }
4001                                                break;
4002                                        case 14:
4003                                                {
4004                                                setState(551);
4005                                                tbody();
4006                                                }
4007                                                break;
4008                                        case 15:
4009                                                {
4010                                                setState(552);
4011                                                thead();
4012                                                }
4013                                                break;
4014                                        case 16:
4015                                                {
4016                                                setState(553);
4017                                                tfoot();
4018                                                }
4019                                                break;
4020                                        case 17:
4021                                                {
4022                                                setState(554);
4023                                                pTagOpen();
4024                                                }
4025                                                break;
4026                                        case 18:
4027                                                {
4028                                                setState(555);
4029                                                liTagOpen();
4030                                                }
4031                                                break;
4032                                        case 19:
4033                                                {
4034                                                setState(556);
4035                                                tdTagOpen();
4036                                                }
4037                                                break;
4038                                        case 20:
4039                                                {
4040                                                setState(557);
4041                                                thTagOpen();
4042                                                }
4043                                                break;
4044                                        case 21:
4045                                                {
4046                                                setState(558);
4047                                                bodyTagOpen();
4048                                                }
4049                                                break;
4050                                        case 22:
4051                                                {
4052                                                setState(559);
4053                                                colgroupTagOpen();
4054                                                }
4055                                                break;
4056                                        case 23:
4057                                                {
4058                                                setState(560);
4059                                                ddTagOpen();
4060                                                }
4061                                                break;
4062                                        case 24:
4063                                                {
4064                                                setState(561);
4065                                                dtTagOpen();
4066                                                }
4067                                                break;
4068                                        case 25:
4069                                                {
4070                                                setState(562);
4071                                                headTagOpen();
4072                                                }
4073                                                break;
4074                                        case 26:
4075                                                {
4076                                                setState(563);
4077                                                htmlTagOpen();
4078                                                }
4079                                                break;
4080                                        case 27:
4081                                                {
4082                                                setState(564);
4083                                                optionTagOpen();
4084                                                }
4085                                                break;
4086                                        case 28:
4087                                                {
4088                                                setState(565);
4089                                                tbodyTagOpen();
4090                                                }
4091                                                break;
4092                                        case 29:
4093                                                {
4094                                                setState(566);
4095                                                theadTagOpen();
4096                                                }
4097                                                break;
4098                                        case 30:
4099                                                {
4100                                                setState(567);
4101                                                tfootTagOpen();
4102                                                }
4103                                                break;
4104                                        case 31:
4105                                                {
4106                                                {
4107                                                setState(568);
4108                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4109                                                setState(569);
4110                                                match(LEADING_ASTERISK);
4111                                                }
4112                                                }
4113                                                break;
4114                                        case 32:
4115                                                {
4116                                                setState(570);
4117                                                htmlComment();
4118                                                }
4119                                                break;
4120                                        case 33:
4121                                                {
4122                                                setState(571);
4123                                                match(CDATA);
4124                                                }
4125                                                break;
4126                                        case 34:
4127                                                {
4128                                                setState(572);
4129                                                match(NEWLINE);
4130                                                }
4131                                                break;
4132                                        case 35:
4133                                                {
4134                                                setState(573);
4135                                                text();
4136                                                }
4137                                                break;
4138                                        case 36:
4139                                                {
4140                                                setState(574);
4141                                                javadocInlineTag();
4142                                                }
4143                                                break;
4144                                        }
4145                                        } 
4146                                }
4147                                setState(579);
4148                                _errHandler.sync(this);
4149                                _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
4150                        }
4151                        setState(580);
4152                        tdTagClose();
4153                        }
4154                }
4155                catch (RecognitionException re) {
4156                        _localctx.exception = re;
4157                        _errHandler.reportError(this, re);
4158                        _errHandler.recover(this, re);
4159                }
4160                finally {
4161                        exitRule();
4162                }
4163                return _localctx;
4164        }
4165
4166        public static class ThTagOpenContext extends ParserRuleContext {
4167                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4168                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4169                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4170                public List<AttributeContext> attribute() {
4171                        return getRuleContexts(AttributeContext.class);
4172                }
4173                public AttributeContext attribute(int i) {
4174                        return getRuleContext(AttributeContext.class,i);
4175                }
4176                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4177                public TerminalNode NEWLINE(int i) {
4178                        return getToken(JavadocParser.NEWLINE, i);
4179                }
4180                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4181                public TerminalNode LEADING_ASTERISK(int i) {
4182                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4183                }
4184                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4185                public TerminalNode WS(int i) {
4186                        return getToken(JavadocParser.WS, i);
4187                }
4188                public ThTagOpenContext(ParserRuleContext parent, int invokingState) {
4189                        super(parent, invokingState);
4190                }
4191                @Override public int getRuleIndex() { return RULE_thTagOpen; }
4192                @Override
4193                public void enterRule(ParseTreeListener listener) {
4194                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this);
4195                }
4196                @Override
4197                public void exitRule(ParseTreeListener listener) {
4198                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this);
4199                }
4200                @Override
4201                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4202                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this);
4203                        else return visitor.visitChildren(this);
4204                }
4205        }
4206
4207        public final ThTagOpenContext thTagOpen() throws RecognitionException {
4208                ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState());
4209                enterRule(_localctx, 36, RULE_thTagOpen);
4210                int _la;
4211                try {
4212                        enterOuterAlt(_localctx, 1);
4213                        {
4214                        setState(582);
4215                        match(OPEN);
4216                        setState(583);
4217                        match(TH_HTML_TAG_NAME);
4218                        setState(590);
4219                        _errHandler.sync(this);
4220                        _la = _input.LA(1);
4221                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4222                                {
4223                                setState(588);
4224                                switch (_input.LA(1)) {
4225                                case HTML_TAG_NAME:
4226                                        {
4227                                        setState(584);
4228                                        attribute();
4229                                        }
4230                                        break;
4231                                case NEWLINE:
4232                                        {
4233                                        setState(585);
4234                                        match(NEWLINE);
4235                                        }
4236                                        break;
4237                                case LEADING_ASTERISK:
4238                                        {
4239                                        setState(586);
4240                                        match(LEADING_ASTERISK);
4241                                        }
4242                                        break;
4243                                case WS:
4244                                        {
4245                                        setState(587);
4246                                        match(WS);
4247                                        }
4248                                        break;
4249                                default:
4250                                        throw new NoViableAltException(this);
4251                                }
4252                                }
4253                                setState(592);
4254                                _errHandler.sync(this);
4255                                _la = _input.LA(1);
4256                        }
4257                        setState(593);
4258                        match(CLOSE);
4259                        }
4260                }
4261                catch (RecognitionException re) {
4262                        _localctx.exception = re;
4263                        _errHandler.reportError(this, re);
4264                        _errHandler.recover(this, re);
4265                }
4266                finally {
4267                        exitRule();
4268                }
4269                return _localctx;
4270        }
4271
4272        public static class ThTagCloseContext extends ParserRuleContext {
4273                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4274                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4275                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4276                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4277                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4278                public TerminalNode NEWLINE(int i) {
4279                        return getToken(JavadocParser.NEWLINE, i);
4280                }
4281                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4282                public TerminalNode LEADING_ASTERISK(int i) {
4283                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4284                }
4285                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4286                public TerminalNode WS(int i) {
4287                        return getToken(JavadocParser.WS, i);
4288                }
4289                public ThTagCloseContext(ParserRuleContext parent, int invokingState) {
4290                        super(parent, invokingState);
4291                }
4292                @Override public int getRuleIndex() { return RULE_thTagClose; }
4293                @Override
4294                public void enterRule(ParseTreeListener listener) {
4295                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this);
4296                }
4297                @Override
4298                public void exitRule(ParseTreeListener listener) {
4299                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this);
4300                }
4301                @Override
4302                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4303                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this);
4304                        else return visitor.visitChildren(this);
4305                }
4306        }
4307
4308        public final ThTagCloseContext thTagClose() throws RecognitionException {
4309                ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState());
4310                enterRule(_localctx, 38, RULE_thTagClose);
4311                int _la;
4312                try {
4313                        enterOuterAlt(_localctx, 1);
4314                        {
4315                        setState(595);
4316                        match(OPEN);
4317                        setState(596);
4318                        match(SLASH);
4319                        setState(597);
4320                        match(TH_HTML_TAG_NAME);
4321                        setState(601);
4322                        _errHandler.sync(this);
4323                        _la = _input.LA(1);
4324                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4325                                {
4326                                {
4327                                setState(598);
4328                                _la = _input.LA(1);
4329                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4330                                _errHandler.recoverInline(this);
4331                                } else {
4332                                        consume();
4333                                }
4334                                }
4335                                }
4336                                setState(603);
4337                                _errHandler.sync(this);
4338                                _la = _input.LA(1);
4339                        }
4340                        setState(604);
4341                        match(CLOSE);
4342                        }
4343                }
4344                catch (RecognitionException re) {
4345                        _localctx.exception = re;
4346                        _errHandler.reportError(this, re);
4347                        _errHandler.recover(this, re);
4348                }
4349                finally {
4350                        exitRule();
4351                }
4352                return _localctx;
4353        }
4354
4355        public static class ThContext extends ParserRuleContext {
4356                public ThTagOpenContext thTagOpen() {
4357                        return getRuleContext(ThTagOpenContext.class,0);
4358                }
4359                public ThTagCloseContext thTagClose() {
4360                        return getRuleContext(ThTagCloseContext.class,0);
4361                }
4362                public List<HtmlTagContext> htmlTag() {
4363                        return getRuleContexts(HtmlTagContext.class);
4364                }
4365                public HtmlTagContext htmlTag(int i) {
4366                        return getRuleContext(HtmlTagContext.class,i);
4367                }
4368                public List<SingletonTagContext> singletonTag() {
4369                        return getRuleContexts(SingletonTagContext.class);
4370                }
4371                public SingletonTagContext singletonTag(int i) {
4372                        return getRuleContext(SingletonTagContext.class,i);
4373                }
4374                public List<ParagraphContext> paragraph() {
4375                        return getRuleContexts(ParagraphContext.class);
4376                }
4377                public ParagraphContext paragraph(int i) {
4378                        return getRuleContext(ParagraphContext.class,i);
4379                }
4380                public List<LiContext> li() {
4381                        return getRuleContexts(LiContext.class);
4382                }
4383                public LiContext li(int i) {
4384                        return getRuleContext(LiContext.class,i);
4385                }
4386                public List<TrContext> tr() {
4387                        return getRuleContexts(TrContext.class);
4388                }
4389                public TrContext tr(int i) {
4390                        return getRuleContext(TrContext.class,i);
4391                }
4392                public List<TdContext> td() {
4393                        return getRuleContexts(TdContext.class);
4394                }
4395                public TdContext td(int i) {
4396                        return getRuleContext(TdContext.class,i);
4397                }
4398                public List<BodyContext> body() {
4399                        return getRuleContexts(BodyContext.class);
4400                }
4401                public BodyContext body(int i) {
4402                        return getRuleContext(BodyContext.class,i);
4403                }
4404                public List<ColgroupContext> colgroup() {
4405                        return getRuleContexts(ColgroupContext.class);
4406                }
4407                public ColgroupContext colgroup(int i) {
4408                        return getRuleContext(ColgroupContext.class,i);
4409                }
4410                public List<DdContext> dd() {
4411                        return getRuleContexts(DdContext.class);
4412                }
4413                public DdContext dd(int i) {
4414                        return getRuleContext(DdContext.class,i);
4415                }
4416                public List<DtContext> dt() {
4417                        return getRuleContexts(DtContext.class);
4418                }
4419                public DtContext dt(int i) {
4420                        return getRuleContext(DtContext.class,i);
4421                }
4422                public List<HeadContext> head() {
4423                        return getRuleContexts(HeadContext.class);
4424                }
4425                public HeadContext head(int i) {
4426                        return getRuleContext(HeadContext.class,i);
4427                }
4428                public List<HtmlContext> html() {
4429                        return getRuleContexts(HtmlContext.class);
4430                }
4431                public HtmlContext html(int i) {
4432                        return getRuleContext(HtmlContext.class,i);
4433                }
4434                public List<OptionContext> option() {
4435                        return getRuleContexts(OptionContext.class);
4436                }
4437                public OptionContext option(int i) {
4438                        return getRuleContext(OptionContext.class,i);
4439                }
4440                public List<TbodyContext> tbody() {
4441                        return getRuleContexts(TbodyContext.class);
4442                }
4443                public TbodyContext tbody(int i) {
4444                        return getRuleContext(TbodyContext.class,i);
4445                }
4446                public List<TheadContext> thead() {
4447                        return getRuleContexts(TheadContext.class);
4448                }
4449                public TheadContext thead(int i) {
4450                        return getRuleContext(TheadContext.class,i);
4451                }
4452                public List<TfootContext> tfoot() {
4453                        return getRuleContexts(TfootContext.class);
4454                }
4455                public TfootContext tfoot(int i) {
4456                        return getRuleContext(TfootContext.class,i);
4457                }
4458                public List<PTagOpenContext> pTagOpen() {
4459                        return getRuleContexts(PTagOpenContext.class);
4460                }
4461                public PTagOpenContext pTagOpen(int i) {
4462                        return getRuleContext(PTagOpenContext.class,i);
4463                }
4464                public List<LiTagOpenContext> liTagOpen() {
4465                        return getRuleContexts(LiTagOpenContext.class);
4466                }
4467                public LiTagOpenContext liTagOpen(int i) {
4468                        return getRuleContext(LiTagOpenContext.class,i);
4469                }
4470                public List<TrTagOpenContext> trTagOpen() {
4471                        return getRuleContexts(TrTagOpenContext.class);
4472                }
4473                public TrTagOpenContext trTagOpen(int i) {
4474                        return getRuleContext(TrTagOpenContext.class,i);
4475                }
4476                public List<TdTagOpenContext> tdTagOpen() {
4477                        return getRuleContexts(TdTagOpenContext.class);
4478                }
4479                public TdTagOpenContext tdTagOpen(int i) {
4480                        return getRuleContext(TdTagOpenContext.class,i);
4481                }
4482                public List<BodyTagOpenContext> bodyTagOpen() {
4483                        return getRuleContexts(BodyTagOpenContext.class);
4484                }
4485                public BodyTagOpenContext bodyTagOpen(int i) {
4486                        return getRuleContext(BodyTagOpenContext.class,i);
4487                }
4488                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4489                        return getRuleContexts(ColgroupTagOpenContext.class);
4490                }
4491                public ColgroupTagOpenContext colgroupTagOpen(int i) {
4492                        return getRuleContext(ColgroupTagOpenContext.class,i);
4493                }
4494                public List<DdTagOpenContext> ddTagOpen() {
4495                        return getRuleContexts(DdTagOpenContext.class);
4496                }
4497                public DdTagOpenContext ddTagOpen(int i) {
4498                        return getRuleContext(DdTagOpenContext.class,i);
4499                }
4500                public List<DtTagOpenContext> dtTagOpen() {
4501                        return getRuleContexts(DtTagOpenContext.class);
4502                }
4503                public DtTagOpenContext dtTagOpen(int i) {
4504                        return getRuleContext(DtTagOpenContext.class,i);
4505                }
4506                public List<HeadTagOpenContext> headTagOpen() {
4507                        return getRuleContexts(HeadTagOpenContext.class);
4508                }
4509                public HeadTagOpenContext headTagOpen(int i) {
4510                        return getRuleContext(HeadTagOpenContext.class,i);
4511                }
4512                public List<HtmlTagOpenContext> htmlTagOpen() {
4513                        return getRuleContexts(HtmlTagOpenContext.class);
4514                }
4515                public HtmlTagOpenContext htmlTagOpen(int i) {
4516                        return getRuleContext(HtmlTagOpenContext.class,i);
4517                }
4518                public List<OptionTagOpenContext> optionTagOpen() {
4519                        return getRuleContexts(OptionTagOpenContext.class);
4520                }
4521                public OptionTagOpenContext optionTagOpen(int i) {
4522                        return getRuleContext(OptionTagOpenContext.class,i);
4523                }
4524                public List<TbodyTagOpenContext> tbodyTagOpen() {
4525                        return getRuleContexts(TbodyTagOpenContext.class);
4526                }
4527                public TbodyTagOpenContext tbodyTagOpen(int i) {
4528                        return getRuleContext(TbodyTagOpenContext.class,i);
4529                }
4530                public List<TheadTagOpenContext> theadTagOpen() {
4531                        return getRuleContexts(TheadTagOpenContext.class);
4532                }
4533                public TheadTagOpenContext theadTagOpen(int i) {
4534                        return getRuleContext(TheadTagOpenContext.class,i);
4535                }
4536                public List<TfootTagOpenContext> tfootTagOpen() {
4537                        return getRuleContexts(TfootTagOpenContext.class);
4538                }
4539                public TfootTagOpenContext tfootTagOpen(int i) {
4540                        return getRuleContext(TfootTagOpenContext.class,i);
4541                }
4542                public List<HtmlCommentContext> htmlComment() {
4543                        return getRuleContexts(HtmlCommentContext.class);
4544                }
4545                public HtmlCommentContext htmlComment(int i) {
4546                        return getRuleContext(HtmlCommentContext.class,i);
4547                }
4548                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4549                public TerminalNode CDATA(int i) {
4550                        return getToken(JavadocParser.CDATA, i);
4551                }
4552                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4553                public TerminalNode NEWLINE(int i) {
4554                        return getToken(JavadocParser.NEWLINE, i);
4555                }
4556                public List<TextContext> text() {
4557                        return getRuleContexts(TextContext.class);
4558                }
4559                public TextContext text(int i) {
4560                        return getRuleContext(TextContext.class,i);
4561                }
4562                public List<JavadocInlineTagContext> javadocInlineTag() {
4563                        return getRuleContexts(JavadocInlineTagContext.class);
4564                }
4565                public JavadocInlineTagContext javadocInlineTag(int i) {
4566                        return getRuleContext(JavadocInlineTagContext.class,i);
4567                }
4568                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4569                public TerminalNode LEADING_ASTERISK(int i) {
4570                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4571                }
4572                public ThContext(ParserRuleContext parent, int invokingState) {
4573                        super(parent, invokingState);
4574                }
4575                @Override public int getRuleIndex() { return RULE_th; }
4576                @Override
4577                public void enterRule(ParseTreeListener listener) {
4578                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this);
4579                }
4580                @Override
4581                public void exitRule(ParseTreeListener listener) {
4582                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this);
4583                }
4584                @Override
4585                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4586                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this);
4587                        else return visitor.visitChildren(this);
4588                }
4589        }
4590
4591        public final ThContext th() throws RecognitionException {
4592                ThContext _localctx = new ThContext(_ctx, getState());
4593                enterRule(_localctx, 40, RULE_th);
4594                try {
4595                        int _alt;
4596                        enterOuterAlt(_localctx, 1);
4597                        {
4598                        setState(606);
4599                        thTagOpen();
4600                        setState(646);
4601                        _errHandler.sync(this);
4602                        _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4603                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4604                                if ( _alt==1 ) {
4605                                        {
4606                                        setState(644);
4607                                        switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
4608                                        case 1:
4609                                                {
4610                                                setState(607);
4611                                                htmlTag();
4612                                                }
4613                                                break;
4614                                        case 2:
4615                                                {
4616                                                setState(608);
4617                                                singletonTag();
4618                                                }
4619                                                break;
4620                                        case 3:
4621                                                {
4622                                                setState(609);
4623                                                paragraph();
4624                                                }
4625                                                break;
4626                                        case 4:
4627                                                {
4628                                                setState(610);
4629                                                li();
4630                                                }
4631                                                break;
4632                                        case 5:
4633                                                {
4634                                                setState(611);
4635                                                tr();
4636                                                }
4637                                                break;
4638                                        case 6:
4639                                                {
4640                                                setState(612);
4641                                                td();
4642                                                }
4643                                                break;
4644                                        case 7:
4645                                                {
4646                                                setState(613);
4647                                                body();
4648                                                }
4649                                                break;
4650                                        case 8:
4651                                                {
4652                                                setState(614);
4653                                                colgroup();
4654                                                }
4655                                                break;
4656                                        case 9:
4657                                                {
4658                                                setState(615);
4659                                                dd();
4660                                                }
4661                                                break;
4662                                        case 10:
4663                                                {
4664                                                setState(616);
4665                                                dt();
4666                                                }
4667                                                break;
4668                                        case 11:
4669                                                {
4670                                                setState(617);
4671                                                head();
4672                                                }
4673                                                break;
4674                                        case 12:
4675                                                {
4676                                                setState(618);
4677                                                html();
4678                                                }
4679                                                break;
4680                                        case 13:
4681                                                {
4682                                                setState(619);
4683                                                option();
4684                                                }
4685                                                break;
4686                                        case 14:
4687                                                {
4688                                                setState(620);
4689                                                tbody();
4690                                                }
4691                                                break;
4692                                        case 15:
4693                                                {
4694                                                setState(621);
4695                                                thead();
4696                                                }
4697                                                break;
4698                                        case 16:
4699                                                {
4700                                                setState(622);
4701                                                tfoot();
4702                                                }
4703                                                break;
4704                                        case 17:
4705                                                {
4706                                                setState(623);
4707                                                pTagOpen();
4708                                                }
4709                                                break;
4710                                        case 18:
4711                                                {
4712                                                setState(624);
4713                                                liTagOpen();
4714                                                }
4715                                                break;
4716                                        case 19:
4717                                                {
4718                                                setState(625);
4719                                                trTagOpen();
4720                                                }
4721                                                break;
4722                                        case 20:
4723                                                {
4724                                                setState(626);
4725                                                tdTagOpen();
4726                                                }
4727                                                break;
4728                                        case 21:
4729                                                {
4730                                                setState(627);
4731                                                bodyTagOpen();
4732                                                }
4733                                                break;
4734                                        case 22:
4735                                                {
4736                                                setState(628);
4737                                                colgroupTagOpen();
4738                                                }
4739                                                break;
4740                                        case 23:
4741                                                {
4742                                                setState(629);
4743                                                ddTagOpen();
4744                                                }
4745                                                break;
4746                                        case 24:
4747                                                {
4748                                                setState(630);
4749                                                dtTagOpen();
4750                                                }
4751                                                break;
4752                                        case 25:
4753                                                {
4754                                                setState(631);
4755                                                headTagOpen();
4756                                                }
4757                                                break;
4758                                        case 26:
4759                                                {
4760                                                setState(632);
4761                                                htmlTagOpen();
4762                                                }
4763                                                break;
4764                                        case 27:
4765                                                {
4766                                                setState(633);
4767                                                optionTagOpen();
4768                                                }
4769                                                break;
4770                                        case 28:
4771                                                {
4772                                                setState(634);
4773                                                tbodyTagOpen();
4774                                                }
4775                                                break;
4776                                        case 29:
4777                                                {
4778                                                setState(635);
4779                                                theadTagOpen();
4780                                                }
4781                                                break;
4782                                        case 30:
4783                                                {
4784                                                setState(636);
4785                                                tfootTagOpen();
4786                                                }
4787                                                break;
4788                                        case 31:
4789                                                {
4790                                                {
4791                                                setState(637);
4792                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4793                                                setState(638);
4794                                                match(LEADING_ASTERISK);
4795                                                }
4796                                                }
4797                                                break;
4798                                        case 32:
4799                                                {
4800                                                setState(639);
4801                                                htmlComment();
4802                                                }
4803                                                break;
4804                                        case 33:
4805                                                {
4806                                                setState(640);
4807                                                match(CDATA);
4808                                                }
4809                                                break;
4810                                        case 34:
4811                                                {
4812                                                setState(641);
4813                                                match(NEWLINE);
4814                                                }
4815                                                break;
4816                                        case 35:
4817                                                {
4818                                                setState(642);
4819                                                text();
4820                                                }
4821                                                break;
4822                                        case 36:
4823                                                {
4824                                                setState(643);
4825                                                javadocInlineTag();
4826                                                }
4827                                                break;
4828                                        }
4829                                        } 
4830                                }
4831                                setState(648);
4832                                _errHandler.sync(this);
4833                                _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4834                        }
4835                        setState(649);
4836                        thTagClose();
4837                        }
4838                }
4839                catch (RecognitionException re) {
4840                        _localctx.exception = re;
4841                        _errHandler.reportError(this, re);
4842                        _errHandler.recover(this, re);
4843                }
4844                finally {
4845                        exitRule();
4846                }
4847                return _localctx;
4848        }
4849
4850        public static class BodyTagOpenContext extends ParserRuleContext {
4851                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4852                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4853                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4854                public List<AttributeContext> attribute() {
4855                        return getRuleContexts(AttributeContext.class);
4856                }
4857                public AttributeContext attribute(int i) {
4858                        return getRuleContext(AttributeContext.class,i);
4859                }
4860                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4861                public TerminalNode NEWLINE(int i) {
4862                        return getToken(JavadocParser.NEWLINE, i);
4863                }
4864                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4865                public TerminalNode LEADING_ASTERISK(int i) {
4866                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4867                }
4868                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4869                public TerminalNode WS(int i) {
4870                        return getToken(JavadocParser.WS, i);
4871                }
4872                public BodyTagOpenContext(ParserRuleContext parent, int invokingState) {
4873                        super(parent, invokingState);
4874                }
4875                @Override public int getRuleIndex() { return RULE_bodyTagOpen; }
4876                @Override
4877                public void enterRule(ParseTreeListener listener) {
4878                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this);
4879                }
4880                @Override
4881                public void exitRule(ParseTreeListener listener) {
4882                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this);
4883                }
4884                @Override
4885                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4886                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this);
4887                        else return visitor.visitChildren(this);
4888                }
4889        }
4890
4891        public final BodyTagOpenContext bodyTagOpen() throws RecognitionException {
4892                BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState());
4893                enterRule(_localctx, 42, RULE_bodyTagOpen);
4894                int _la;
4895                try {
4896                        enterOuterAlt(_localctx, 1);
4897                        {
4898                        setState(651);
4899                        match(OPEN);
4900                        setState(652);
4901                        match(BODY_HTML_TAG_NAME);
4902                        setState(659);
4903                        _errHandler.sync(this);
4904                        _la = _input.LA(1);
4905                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4906                                {
4907                                setState(657);
4908                                switch (_input.LA(1)) {
4909                                case HTML_TAG_NAME:
4910                                        {
4911                                        setState(653);
4912                                        attribute();
4913                                        }
4914                                        break;
4915                                case NEWLINE:
4916                                        {
4917                                        setState(654);
4918                                        match(NEWLINE);
4919                                        }
4920                                        break;
4921                                case LEADING_ASTERISK:
4922                                        {
4923                                        setState(655);
4924                                        match(LEADING_ASTERISK);
4925                                        }
4926                                        break;
4927                                case WS:
4928                                        {
4929                                        setState(656);
4930                                        match(WS);
4931                                        }
4932                                        break;
4933                                default:
4934                                        throw new NoViableAltException(this);
4935                                }
4936                                }
4937                                setState(661);
4938                                _errHandler.sync(this);
4939                                _la = _input.LA(1);
4940                        }
4941                        setState(662);
4942                        match(CLOSE);
4943                        }
4944                }
4945                catch (RecognitionException re) {
4946                        _localctx.exception = re;
4947                        _errHandler.reportError(this, re);
4948                        _errHandler.recover(this, re);
4949                }
4950                finally {
4951                        exitRule();
4952                }
4953                return _localctx;
4954        }
4955
4956        public static class BodyTagCloseContext extends ParserRuleContext {
4957                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4958                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4959                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4960                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4961                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4962                public TerminalNode NEWLINE(int i) {
4963                        return getToken(JavadocParser.NEWLINE, i);
4964                }
4965                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4966                public TerminalNode LEADING_ASTERISK(int i) {
4967                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4968                }
4969                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4970                public TerminalNode WS(int i) {
4971                        return getToken(JavadocParser.WS, i);
4972                }
4973                public BodyTagCloseContext(ParserRuleContext parent, int invokingState) {
4974                        super(parent, invokingState);
4975                }
4976                @Override public int getRuleIndex() { return RULE_bodyTagClose; }
4977                @Override
4978                public void enterRule(ParseTreeListener listener) {
4979                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this);
4980                }
4981                @Override
4982                public void exitRule(ParseTreeListener listener) {
4983                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this);
4984                }
4985                @Override
4986                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4987                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this);
4988                        else return visitor.visitChildren(this);
4989                }
4990        }
4991
4992        public final BodyTagCloseContext bodyTagClose() throws RecognitionException {
4993                BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState());
4994                enterRule(_localctx, 44, RULE_bodyTagClose);
4995                int _la;
4996                try {
4997                        enterOuterAlt(_localctx, 1);
4998                        {
4999                        setState(664);
5000                        match(OPEN);
5001                        setState(665);
5002                        match(SLASH);
5003                        setState(666);
5004                        match(BODY_HTML_TAG_NAME);
5005                        setState(670);
5006                        _errHandler.sync(this);
5007                        _la = _input.LA(1);
5008                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5009                                {
5010                                {
5011                                setState(667);
5012                                _la = _input.LA(1);
5013                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5014                                _errHandler.recoverInline(this);
5015                                } else {
5016                                        consume();
5017                                }
5018                                }
5019                                }
5020                                setState(672);
5021                                _errHandler.sync(this);
5022                                _la = _input.LA(1);
5023                        }
5024                        setState(673);
5025                        match(CLOSE);
5026                        }
5027                }
5028                catch (RecognitionException re) {
5029                        _localctx.exception = re;
5030                        _errHandler.reportError(this, re);
5031                        _errHandler.recover(this, re);
5032                }
5033                finally {
5034                        exitRule();
5035                }
5036                return _localctx;
5037        }
5038
5039        public static class BodyContext extends ParserRuleContext {
5040                public BodyTagOpenContext bodyTagOpen() {
5041                        return getRuleContext(BodyTagOpenContext.class,0);
5042                }
5043                public BodyTagCloseContext bodyTagClose() {
5044                        return getRuleContext(BodyTagCloseContext.class,0);
5045                }
5046                public List<HtmlTagContext> htmlTag() {
5047                        return getRuleContexts(HtmlTagContext.class);
5048                }
5049                public HtmlTagContext htmlTag(int i) {
5050                        return getRuleContext(HtmlTagContext.class,i);
5051                }
5052                public List<SingletonTagContext> singletonTag() {
5053                        return getRuleContexts(SingletonTagContext.class);
5054                }
5055                public SingletonTagContext singletonTag(int i) {
5056                        return getRuleContext(SingletonTagContext.class,i);
5057                }
5058                public List<ParagraphContext> paragraph() {
5059                        return getRuleContexts(ParagraphContext.class);
5060                }
5061                public ParagraphContext paragraph(int i) {
5062                        return getRuleContext(ParagraphContext.class,i);
5063                }
5064                public List<LiContext> li() {
5065                        return getRuleContexts(LiContext.class);
5066                }
5067                public LiContext li(int i) {
5068                        return getRuleContext(LiContext.class,i);
5069                }
5070                public List<TrContext> tr() {
5071                        return getRuleContexts(TrContext.class);
5072                }
5073                public TrContext tr(int i) {
5074                        return getRuleContext(TrContext.class,i);
5075                }
5076                public List<TdContext> td() {
5077                        return getRuleContexts(TdContext.class);
5078                }
5079                public TdContext td(int i) {
5080                        return getRuleContext(TdContext.class,i);
5081                }
5082                public List<ThContext> th() {
5083                        return getRuleContexts(ThContext.class);
5084                }
5085                public ThContext th(int i) {
5086                        return getRuleContext(ThContext.class,i);
5087                }
5088                public List<ColgroupContext> colgroup() {
5089                        return getRuleContexts(ColgroupContext.class);
5090                }
5091                public ColgroupContext colgroup(int i) {
5092                        return getRuleContext(ColgroupContext.class,i);
5093                }
5094                public List<DdContext> dd() {
5095                        return getRuleContexts(DdContext.class);
5096                }
5097                public DdContext dd(int i) {
5098                        return getRuleContext(DdContext.class,i);
5099                }
5100                public List<DtContext> dt() {
5101                        return getRuleContexts(DtContext.class);
5102                }
5103                public DtContext dt(int i) {
5104                        return getRuleContext(DtContext.class,i);
5105                }
5106                public List<HeadContext> head() {
5107                        return getRuleContexts(HeadContext.class);
5108                }
5109                public HeadContext head(int i) {
5110                        return getRuleContext(HeadContext.class,i);
5111                }
5112                public List<HtmlContext> html() {
5113                        return getRuleContexts(HtmlContext.class);
5114                }
5115                public HtmlContext html(int i) {
5116                        return getRuleContext(HtmlContext.class,i);
5117                }
5118                public List<OptionContext> option() {
5119                        return getRuleContexts(OptionContext.class);
5120                }
5121                public OptionContext option(int i) {
5122                        return getRuleContext(OptionContext.class,i);
5123                }
5124                public List<TbodyContext> tbody() {
5125                        return getRuleContexts(TbodyContext.class);
5126                }
5127                public TbodyContext tbody(int i) {
5128                        return getRuleContext(TbodyContext.class,i);
5129                }
5130                public List<TheadContext> thead() {
5131                        return getRuleContexts(TheadContext.class);
5132                }
5133                public TheadContext thead(int i) {
5134                        return getRuleContext(TheadContext.class,i);
5135                }
5136                public List<TfootContext> tfoot() {
5137                        return getRuleContexts(TfootContext.class);
5138                }
5139                public TfootContext tfoot(int i) {
5140                        return getRuleContext(TfootContext.class,i);
5141                }
5142                public List<PTagOpenContext> pTagOpen() {
5143                        return getRuleContexts(PTagOpenContext.class);
5144                }
5145                public PTagOpenContext pTagOpen(int i) {
5146                        return getRuleContext(PTagOpenContext.class,i);
5147                }
5148                public List<LiTagOpenContext> liTagOpen() {
5149                        return getRuleContexts(LiTagOpenContext.class);
5150                }
5151                public LiTagOpenContext liTagOpen(int i) {
5152                        return getRuleContext(LiTagOpenContext.class,i);
5153                }
5154                public List<TrTagOpenContext> trTagOpen() {
5155                        return getRuleContexts(TrTagOpenContext.class);
5156                }
5157                public TrTagOpenContext trTagOpen(int i) {
5158                        return getRuleContext(TrTagOpenContext.class,i);
5159                }
5160                public List<TdTagOpenContext> tdTagOpen() {
5161                        return getRuleContexts(TdTagOpenContext.class);
5162                }
5163                public TdTagOpenContext tdTagOpen(int i) {
5164                        return getRuleContext(TdTagOpenContext.class,i);
5165                }
5166                public List<ThTagOpenContext> thTagOpen() {
5167                        return getRuleContexts(ThTagOpenContext.class);
5168                }
5169                public ThTagOpenContext thTagOpen(int i) {
5170                        return getRuleContext(ThTagOpenContext.class,i);
5171                }
5172                public List<ColgroupTagOpenContext> colgroupTagOpen() {
5173                        return getRuleContexts(ColgroupTagOpenContext.class);
5174                }
5175                public ColgroupTagOpenContext colgroupTagOpen(int i) {
5176                        return getRuleContext(ColgroupTagOpenContext.class,i);
5177                }
5178                public List<DdTagOpenContext> ddTagOpen() {
5179                        return getRuleContexts(DdTagOpenContext.class);
5180                }
5181                public DdTagOpenContext ddTagOpen(int i) {
5182                        return getRuleContext(DdTagOpenContext.class,i);
5183                }
5184                public List<DtTagOpenContext> dtTagOpen() {
5185                        return getRuleContexts(DtTagOpenContext.class);
5186                }
5187                public DtTagOpenContext dtTagOpen(int i) {
5188                        return getRuleContext(DtTagOpenContext.class,i);
5189                }
5190                public List<HeadTagOpenContext> headTagOpen() {
5191                        return getRuleContexts(HeadTagOpenContext.class);
5192                }
5193                public HeadTagOpenContext headTagOpen(int i) {
5194                        return getRuleContext(HeadTagOpenContext.class,i);
5195                }
5196                public List<HtmlTagOpenContext> htmlTagOpen() {
5197                        return getRuleContexts(HtmlTagOpenContext.class);
5198                }
5199                public HtmlTagOpenContext htmlTagOpen(int i) {
5200                        return getRuleContext(HtmlTagOpenContext.class,i);
5201                }
5202                public List<OptionTagOpenContext> optionTagOpen() {
5203                        return getRuleContexts(OptionTagOpenContext.class);
5204                }
5205                public OptionTagOpenContext optionTagOpen(int i) {
5206                        return getRuleContext(OptionTagOpenContext.class,i);
5207                }
5208                public List<TbodyTagOpenContext> tbodyTagOpen() {
5209                        return getRuleContexts(TbodyTagOpenContext.class);
5210                }
5211                public TbodyTagOpenContext tbodyTagOpen(int i) {
5212                        return getRuleContext(TbodyTagOpenContext.class,i);
5213                }
5214                public List<TheadTagOpenContext> theadTagOpen() {
5215                        return getRuleContexts(TheadTagOpenContext.class);
5216                }
5217                public TheadTagOpenContext theadTagOpen(int i) {
5218                        return getRuleContext(TheadTagOpenContext.class,i);
5219                }
5220                public List<TfootTagOpenContext> tfootTagOpen() {
5221                        return getRuleContexts(TfootTagOpenContext.class);
5222                }
5223                public TfootTagOpenContext tfootTagOpen(int i) {
5224                        return getRuleContext(TfootTagOpenContext.class,i);
5225                }
5226                public List<HtmlCommentContext> htmlComment() {
5227                        return getRuleContexts(HtmlCommentContext.class);
5228                }
5229                public HtmlCommentContext htmlComment(int i) {
5230                        return getRuleContext(HtmlCommentContext.class,i);
5231                }
5232                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5233                public TerminalNode CDATA(int i) {
5234                        return getToken(JavadocParser.CDATA, i);
5235                }
5236                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5237                public TerminalNode NEWLINE(int i) {
5238                        return getToken(JavadocParser.NEWLINE, i);
5239                }
5240                public List<TextContext> text() {
5241                        return getRuleContexts(TextContext.class);
5242                }
5243                public TextContext text(int i) {
5244                        return getRuleContext(TextContext.class,i);
5245                }
5246                public List<JavadocInlineTagContext> javadocInlineTag() {
5247                        return getRuleContexts(JavadocInlineTagContext.class);
5248                }
5249                public JavadocInlineTagContext javadocInlineTag(int i) {
5250                        return getRuleContext(JavadocInlineTagContext.class,i);
5251                }
5252                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5253                public TerminalNode LEADING_ASTERISK(int i) {
5254                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5255                }
5256                public BodyContext(ParserRuleContext parent, int invokingState) {
5257                        super(parent, invokingState);
5258                }
5259                @Override public int getRuleIndex() { return RULE_body; }
5260                @Override
5261                public void enterRule(ParseTreeListener listener) {
5262                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this);
5263                }
5264                @Override
5265                public void exitRule(ParseTreeListener listener) {
5266                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this);
5267                }
5268                @Override
5269                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5270                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this);
5271                        else return visitor.visitChildren(this);
5272                }
5273        }
5274
5275        public final BodyContext body() throws RecognitionException {
5276                BodyContext _localctx = new BodyContext(_ctx, getState());
5277                enterRule(_localctx, 46, RULE_body);
5278                try {
5279                        int _alt;
5280                        enterOuterAlt(_localctx, 1);
5281                        {
5282                        setState(675);
5283                        bodyTagOpen();
5284                        setState(715);
5285                        _errHandler.sync(this);
5286                        _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5287                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5288                                if ( _alt==1 ) {
5289                                        {
5290                                        setState(713);
5291                                        switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
5292                                        case 1:
5293                                                {
5294                                                setState(676);
5295                                                htmlTag();
5296                                                }
5297                                                break;
5298                                        case 2:
5299                                                {
5300                                                setState(677);
5301                                                singletonTag();
5302                                                }
5303                                                break;
5304                                        case 3:
5305                                                {
5306                                                setState(678);
5307                                                paragraph();
5308                                                }
5309                                                break;
5310                                        case 4:
5311                                                {
5312                                                setState(679);
5313                                                li();
5314                                                }
5315                                                break;
5316                                        case 5:
5317                                                {
5318                                                setState(680);
5319                                                tr();
5320                                                }
5321                                                break;
5322                                        case 6:
5323                                                {
5324                                                setState(681);
5325                                                td();
5326                                                }
5327                                                break;
5328                                        case 7:
5329                                                {
5330                                                setState(682);
5331                                                th();
5332                                                }
5333                                                break;
5334                                        case 8:
5335                                                {
5336                                                setState(683);
5337                                                colgroup();
5338                                                }
5339                                                break;
5340                                        case 9:
5341                                                {
5342                                                setState(684);
5343                                                dd();
5344                                                }
5345                                                break;
5346                                        case 10:
5347                                                {
5348                                                setState(685);
5349                                                dt();
5350                                                }
5351                                                break;
5352                                        case 11:
5353                                                {
5354                                                setState(686);
5355                                                head();
5356                                                }
5357                                                break;
5358                                        case 12:
5359                                                {
5360                                                setState(687);
5361                                                html();
5362                                                }
5363                                                break;
5364                                        case 13:
5365                                                {
5366                                                setState(688);
5367                                                option();
5368                                                }
5369                                                break;
5370                                        case 14:
5371                                                {
5372                                                setState(689);
5373                                                tbody();
5374                                                }
5375                                                break;
5376                                        case 15:
5377                                                {
5378                                                setState(690);
5379                                                thead();
5380                                                }
5381                                                break;
5382                                        case 16:
5383                                                {
5384                                                setState(691);
5385                                                tfoot();
5386                                                }
5387                                                break;
5388                                        case 17:
5389                                                {
5390                                                setState(692);
5391                                                pTagOpen();
5392                                                }
5393                                                break;
5394                                        case 18:
5395                                                {
5396                                                setState(693);
5397                                                liTagOpen();
5398                                                }
5399                                                break;
5400                                        case 19:
5401                                                {
5402                                                setState(694);
5403                                                trTagOpen();
5404                                                }
5405                                                break;
5406                                        case 20:
5407                                                {
5408                                                setState(695);
5409                                                tdTagOpen();
5410                                                }
5411                                                break;
5412                                        case 21:
5413                                                {
5414                                                setState(696);
5415                                                thTagOpen();
5416                                                }
5417                                                break;
5418                                        case 22:
5419                                                {
5420                                                setState(697);
5421                                                colgroupTagOpen();
5422                                                }
5423                                                break;
5424                                        case 23:
5425                                                {
5426                                                setState(698);
5427                                                ddTagOpen();
5428                                                }
5429                                                break;
5430                                        case 24:
5431                                                {
5432                                                setState(699);
5433                                                dtTagOpen();
5434                                                }
5435                                                break;
5436                                        case 25:
5437                                                {
5438                                                setState(700);
5439                                                headTagOpen();
5440                                                }
5441                                                break;
5442                                        case 26:
5443                                                {
5444                                                setState(701);
5445                                                htmlTagOpen();
5446                                                }
5447                                                break;
5448                                        case 27:
5449                                                {
5450                                                setState(702);
5451                                                optionTagOpen();
5452                                                }
5453                                                break;
5454                                        case 28:
5455                                                {
5456                                                setState(703);
5457                                                tbodyTagOpen();
5458                                                }
5459                                                break;
5460                                        case 29:
5461                                                {
5462                                                setState(704);
5463                                                theadTagOpen();
5464                                                }
5465                                                break;
5466                                        case 30:
5467                                                {
5468                                                setState(705);
5469                                                tfootTagOpen();
5470                                                }
5471                                                break;
5472                                        case 31:
5473                                                {
5474                                                {
5475                                                setState(706);
5476                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5477                                                setState(707);
5478                                                match(LEADING_ASTERISK);
5479                                                }
5480                                                }
5481                                                break;
5482                                        case 32:
5483                                                {
5484                                                setState(708);
5485                                                htmlComment();
5486                                                }
5487                                                break;
5488                                        case 33:
5489                                                {
5490                                                setState(709);
5491                                                match(CDATA);
5492                                                }
5493                                                break;
5494                                        case 34:
5495                                                {
5496                                                setState(710);
5497                                                match(NEWLINE);
5498                                                }
5499                                                break;
5500                                        case 35:
5501                                                {
5502                                                setState(711);
5503                                                text();
5504                                                }
5505                                                break;
5506                                        case 36:
5507                                                {
5508                                                setState(712);
5509                                                javadocInlineTag();
5510                                                }
5511                                                break;
5512                                        }
5513                                        } 
5514                                }
5515                                setState(717);
5516                                _errHandler.sync(this);
5517                                _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5518                        }
5519                        setState(718);
5520                        bodyTagClose();
5521                        }
5522                }
5523                catch (RecognitionException re) {
5524                        _localctx.exception = re;
5525                        _errHandler.reportError(this, re);
5526                        _errHandler.recover(this, re);
5527                }
5528                finally {
5529                        exitRule();
5530                }
5531                return _localctx;
5532        }
5533
5534        public static class ColgroupTagOpenContext extends ParserRuleContext {
5535                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5536                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5537                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5538                public List<AttributeContext> attribute() {
5539                        return getRuleContexts(AttributeContext.class);
5540                }
5541                public AttributeContext attribute(int i) {
5542                        return getRuleContext(AttributeContext.class,i);
5543                }
5544                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5545                public TerminalNode NEWLINE(int i) {
5546                        return getToken(JavadocParser.NEWLINE, i);
5547                }
5548                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5549                public TerminalNode LEADING_ASTERISK(int i) {
5550                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5551                }
5552                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5553                public TerminalNode WS(int i) {
5554                        return getToken(JavadocParser.WS, i);
5555                }
5556                public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) {
5557                        super(parent, invokingState);
5558                }
5559                @Override public int getRuleIndex() { return RULE_colgroupTagOpen; }
5560                @Override
5561                public void enterRule(ParseTreeListener listener) {
5562                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this);
5563                }
5564                @Override
5565                public void exitRule(ParseTreeListener listener) {
5566                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this);
5567                }
5568                @Override
5569                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5570                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this);
5571                        else return visitor.visitChildren(this);
5572                }
5573        }
5574
5575        public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException {
5576                ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState());
5577                enterRule(_localctx, 48, RULE_colgroupTagOpen);
5578                int _la;
5579                try {
5580                        enterOuterAlt(_localctx, 1);
5581                        {
5582                        setState(720);
5583                        match(OPEN);
5584                        setState(721);
5585                        match(COLGROUP_HTML_TAG_NAME);
5586                        setState(728);
5587                        _errHandler.sync(this);
5588                        _la = _input.LA(1);
5589                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5590                                {
5591                                setState(726);
5592                                switch (_input.LA(1)) {
5593                                case HTML_TAG_NAME:
5594                                        {
5595                                        setState(722);
5596                                        attribute();
5597                                        }
5598                                        break;
5599                                case NEWLINE:
5600                                        {
5601                                        setState(723);
5602                                        match(NEWLINE);
5603                                        }
5604                                        break;
5605                                case LEADING_ASTERISK:
5606                                        {
5607                                        setState(724);
5608                                        match(LEADING_ASTERISK);
5609                                        }
5610                                        break;
5611                                case WS:
5612                                        {
5613                                        setState(725);
5614                                        match(WS);
5615                                        }
5616                                        break;
5617                                default:
5618                                        throw new NoViableAltException(this);
5619                                }
5620                                }
5621                                setState(730);
5622                                _errHandler.sync(this);
5623                                _la = _input.LA(1);
5624                        }
5625                        setState(731);
5626                        match(CLOSE);
5627                        }
5628                }
5629                catch (RecognitionException re) {
5630                        _localctx.exception = re;
5631                        _errHandler.reportError(this, re);
5632                        _errHandler.recover(this, re);
5633                }
5634                finally {
5635                        exitRule();
5636                }
5637                return _localctx;
5638        }
5639
5640        public static class ColgroupTagCloseContext extends ParserRuleContext {
5641                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5642                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5643                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5644                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5645                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5646                public TerminalNode NEWLINE(int i) {
5647                        return getToken(JavadocParser.NEWLINE, i);
5648                }
5649                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5650                public TerminalNode LEADING_ASTERISK(int i) {
5651                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5652                }
5653                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5654                public TerminalNode WS(int i) {
5655                        return getToken(JavadocParser.WS, i);
5656                }
5657                public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) {
5658                        super(parent, invokingState);
5659                }
5660                @Override public int getRuleIndex() { return RULE_colgroupTagClose; }
5661                @Override
5662                public void enterRule(ParseTreeListener listener) {
5663                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this);
5664                }
5665                @Override
5666                public void exitRule(ParseTreeListener listener) {
5667                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this);
5668                }
5669                @Override
5670                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5671                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this);
5672                        else return visitor.visitChildren(this);
5673                }
5674        }
5675
5676        public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException {
5677                ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState());
5678                enterRule(_localctx, 50, RULE_colgroupTagClose);
5679                int _la;
5680                try {
5681                        enterOuterAlt(_localctx, 1);
5682                        {
5683                        setState(733);
5684                        match(OPEN);
5685                        setState(734);
5686                        match(SLASH);
5687                        setState(735);
5688                        match(COLGROUP_HTML_TAG_NAME);
5689                        setState(739);
5690                        _errHandler.sync(this);
5691                        _la = _input.LA(1);
5692                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5693                                {
5694                                {
5695                                setState(736);
5696                                _la = _input.LA(1);
5697                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5698                                _errHandler.recoverInline(this);
5699                                } else {
5700                                        consume();
5701                                }
5702                                }
5703                                }
5704                                setState(741);
5705                                _errHandler.sync(this);
5706                                _la = _input.LA(1);
5707                        }
5708                        setState(742);
5709                        match(CLOSE);
5710                        }
5711                }
5712                catch (RecognitionException re) {
5713                        _localctx.exception = re;
5714                        _errHandler.reportError(this, re);
5715                        _errHandler.recover(this, re);
5716                }
5717                finally {
5718                        exitRule();
5719                }
5720                return _localctx;
5721        }
5722
5723        public static class ColgroupContext extends ParserRuleContext {
5724                public ColgroupTagOpenContext colgroupTagOpen() {
5725                        return getRuleContext(ColgroupTagOpenContext.class,0);
5726                }
5727                public ColgroupTagCloseContext colgroupTagClose() {
5728                        return getRuleContext(ColgroupTagCloseContext.class,0);
5729                }
5730                public List<HtmlTagContext> htmlTag() {
5731                        return getRuleContexts(HtmlTagContext.class);
5732                }
5733                public HtmlTagContext htmlTag(int i) {
5734                        return getRuleContext(HtmlTagContext.class,i);
5735                }
5736                public List<SingletonTagContext> singletonTag() {
5737                        return getRuleContexts(SingletonTagContext.class);
5738                }
5739                public SingletonTagContext singletonTag(int i) {
5740                        return getRuleContext(SingletonTagContext.class,i);
5741                }
5742                public List<ParagraphContext> paragraph() {
5743                        return getRuleContexts(ParagraphContext.class);
5744                }
5745                public ParagraphContext paragraph(int i) {
5746                        return getRuleContext(ParagraphContext.class,i);
5747                }
5748                public List<LiContext> li() {
5749                        return getRuleContexts(LiContext.class);
5750                }
5751                public LiContext li(int i) {
5752                        return getRuleContext(LiContext.class,i);
5753                }
5754                public List<TrContext> tr() {
5755                        return getRuleContexts(TrContext.class);
5756                }
5757                public TrContext tr(int i) {
5758                        return getRuleContext(TrContext.class,i);
5759                }
5760                public List<TdContext> td() {
5761                        return getRuleContexts(TdContext.class);
5762                }
5763                public TdContext td(int i) {
5764                        return getRuleContext(TdContext.class,i);
5765                }
5766                public List<ThContext> th() {
5767                        return getRuleContexts(ThContext.class);
5768                }
5769                public ThContext th(int i) {
5770                        return getRuleContext(ThContext.class,i);
5771                }
5772                public List<BodyContext> body() {
5773                        return getRuleContexts(BodyContext.class);
5774                }
5775                public BodyContext body(int i) {
5776                        return getRuleContext(BodyContext.class,i);
5777                }
5778                public List<DdContext> dd() {
5779                        return getRuleContexts(DdContext.class);
5780                }
5781                public DdContext dd(int i) {
5782                        return getRuleContext(DdContext.class,i);
5783                }
5784                public List<DtContext> dt() {
5785                        return getRuleContexts(DtContext.class);
5786                }
5787                public DtContext dt(int i) {
5788                        return getRuleContext(DtContext.class,i);
5789                }
5790                public List<HeadContext> head() {
5791                        return getRuleContexts(HeadContext.class);
5792                }
5793                public HeadContext head(int i) {
5794                        return getRuleContext(HeadContext.class,i);
5795                }
5796                public List<HtmlContext> html() {
5797                        return getRuleContexts(HtmlContext.class);
5798                }
5799                public HtmlContext html(int i) {
5800                        return getRuleContext(HtmlContext.class,i);
5801                }
5802                public List<OptionContext> option() {
5803                        return getRuleContexts(OptionContext.class);
5804                }
5805                public OptionContext option(int i) {
5806                        return getRuleContext(OptionContext.class,i);
5807                }
5808                public List<TbodyContext> tbody() {
5809                        return getRuleContexts(TbodyContext.class);
5810                }
5811                public TbodyContext tbody(int i) {
5812                        return getRuleContext(TbodyContext.class,i);
5813                }
5814                public List<TheadContext> thead() {
5815                        return getRuleContexts(TheadContext.class);
5816                }
5817                public TheadContext thead(int i) {
5818                        return getRuleContext(TheadContext.class,i);
5819                }
5820                public List<TfootContext> tfoot() {
5821                        return getRuleContexts(TfootContext.class);
5822                }
5823                public TfootContext tfoot(int i) {
5824                        return getRuleContext(TfootContext.class,i);
5825                }
5826                public List<PTagOpenContext> pTagOpen() {
5827                        return getRuleContexts(PTagOpenContext.class);
5828                }
5829                public PTagOpenContext pTagOpen(int i) {
5830                        return getRuleContext(PTagOpenContext.class,i);
5831                }
5832                public List<LiTagOpenContext> liTagOpen() {
5833                        return getRuleContexts(LiTagOpenContext.class);
5834                }
5835                public LiTagOpenContext liTagOpen(int i) {
5836                        return getRuleContext(LiTagOpenContext.class,i);
5837                }
5838                public List<TrTagOpenContext> trTagOpen() {
5839                        return getRuleContexts(TrTagOpenContext.class);
5840                }
5841                public TrTagOpenContext trTagOpen(int i) {
5842                        return getRuleContext(TrTagOpenContext.class,i);
5843                }
5844                public List<TdTagOpenContext> tdTagOpen() {
5845                        return getRuleContexts(TdTagOpenContext.class);
5846                }
5847                public TdTagOpenContext tdTagOpen(int i) {
5848                        return getRuleContext(TdTagOpenContext.class,i);
5849                }
5850                public List<ThTagOpenContext> thTagOpen() {
5851                        return getRuleContexts(ThTagOpenContext.class);
5852                }
5853                public ThTagOpenContext thTagOpen(int i) {
5854                        return getRuleContext(ThTagOpenContext.class,i);
5855                }
5856                public List<BodyTagOpenContext> bodyTagOpen() {
5857                        return getRuleContexts(BodyTagOpenContext.class);
5858                }
5859                public BodyTagOpenContext bodyTagOpen(int i) {
5860                        return getRuleContext(BodyTagOpenContext.class,i);
5861                }
5862                public List<DdTagOpenContext> ddTagOpen() {
5863                        return getRuleContexts(DdTagOpenContext.class);
5864                }
5865                public DdTagOpenContext ddTagOpen(int i) {
5866                        return getRuleContext(DdTagOpenContext.class,i);
5867                }
5868                public List<DtTagOpenContext> dtTagOpen() {
5869                        return getRuleContexts(DtTagOpenContext.class);
5870                }
5871                public DtTagOpenContext dtTagOpen(int i) {
5872                        return getRuleContext(DtTagOpenContext.class,i);
5873                }
5874                public List<HeadTagOpenContext> headTagOpen() {
5875                        return getRuleContexts(HeadTagOpenContext.class);
5876                }
5877                public HeadTagOpenContext headTagOpen(int i) {
5878                        return getRuleContext(HeadTagOpenContext.class,i);
5879                }
5880                public List<HtmlTagOpenContext> htmlTagOpen() {
5881                        return getRuleContexts(HtmlTagOpenContext.class);
5882                }
5883                public HtmlTagOpenContext htmlTagOpen(int i) {
5884                        return getRuleContext(HtmlTagOpenContext.class,i);
5885                }
5886                public List<OptionTagOpenContext> optionTagOpen() {
5887                        return getRuleContexts(OptionTagOpenContext.class);
5888                }
5889                public OptionTagOpenContext optionTagOpen(int i) {
5890                        return getRuleContext(OptionTagOpenContext.class,i);
5891                }
5892                public List<TbodyTagOpenContext> tbodyTagOpen() {
5893                        return getRuleContexts(TbodyTagOpenContext.class);
5894                }
5895                public TbodyTagOpenContext tbodyTagOpen(int i) {
5896                        return getRuleContext(TbodyTagOpenContext.class,i);
5897                }
5898                public List<TheadTagOpenContext> theadTagOpen() {
5899                        return getRuleContexts(TheadTagOpenContext.class);
5900                }
5901                public TheadTagOpenContext theadTagOpen(int i) {
5902                        return getRuleContext(TheadTagOpenContext.class,i);
5903                }
5904                public List<TfootTagOpenContext> tfootTagOpen() {
5905                        return getRuleContexts(TfootTagOpenContext.class);
5906                }
5907                public TfootTagOpenContext tfootTagOpen(int i) {
5908                        return getRuleContext(TfootTagOpenContext.class,i);
5909                }
5910                public List<HtmlCommentContext> htmlComment() {
5911                        return getRuleContexts(HtmlCommentContext.class);
5912                }
5913                public HtmlCommentContext htmlComment(int i) {
5914                        return getRuleContext(HtmlCommentContext.class,i);
5915                }
5916                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5917                public TerminalNode CDATA(int i) {
5918                        return getToken(JavadocParser.CDATA, i);
5919                }
5920                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5921                public TerminalNode NEWLINE(int i) {
5922                        return getToken(JavadocParser.NEWLINE, i);
5923                }
5924                public List<TextContext> text() {
5925                        return getRuleContexts(TextContext.class);
5926                }
5927                public TextContext text(int i) {
5928                        return getRuleContext(TextContext.class,i);
5929                }
5930                public List<JavadocInlineTagContext> javadocInlineTag() {
5931                        return getRuleContexts(JavadocInlineTagContext.class);
5932                }
5933                public JavadocInlineTagContext javadocInlineTag(int i) {
5934                        return getRuleContext(JavadocInlineTagContext.class,i);
5935                }
5936                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5937                public TerminalNode LEADING_ASTERISK(int i) {
5938                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5939                }
5940                public ColgroupContext(ParserRuleContext parent, int invokingState) {
5941                        super(parent, invokingState);
5942                }
5943                @Override public int getRuleIndex() { return RULE_colgroup; }
5944                @Override
5945                public void enterRule(ParseTreeListener listener) {
5946                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this);
5947                }
5948                @Override
5949                public void exitRule(ParseTreeListener listener) {
5950                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this);
5951                }
5952                @Override
5953                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5954                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this);
5955                        else return visitor.visitChildren(this);
5956                }
5957        }
5958
5959        public final ColgroupContext colgroup() throws RecognitionException {
5960                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
5961                enterRule(_localctx, 52, RULE_colgroup);
5962                try {
5963                        int _alt;
5964                        enterOuterAlt(_localctx, 1);
5965                        {
5966                        setState(744);
5967                        colgroupTagOpen();
5968                        setState(784);
5969                        _errHandler.sync(this);
5970                        _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
5971                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5972                                if ( _alt==1 ) {
5973                                        {
5974                                        setState(782);
5975                                        switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
5976                                        case 1:
5977                                                {
5978                                                setState(745);
5979                                                htmlTag();
5980                                                }
5981                                                break;
5982                                        case 2:
5983                                                {
5984                                                setState(746);
5985                                                singletonTag();
5986                                                }
5987                                                break;
5988                                        case 3:
5989                                                {
5990                                                setState(747);
5991                                                paragraph();
5992                                                }
5993                                                break;
5994                                        case 4:
5995                                                {
5996                                                setState(748);
5997                                                li();
5998                                                }
5999                                                break;
6000                                        case 5:
6001                                                {
6002                                                setState(749);
6003                                                tr();
6004                                                }
6005                                                break;
6006                                        case 6:
6007                                                {
6008                                                setState(750);
6009                                                td();
6010                                                }
6011                                                break;
6012                                        case 7:
6013                                                {
6014                                                setState(751);
6015                                                th();
6016                                                }
6017                                                break;
6018                                        case 8:
6019                                                {
6020                                                setState(752);
6021                                                body();
6022                                                }
6023                                                break;
6024                                        case 9:
6025                                                {
6026                                                setState(753);
6027                                                dd();
6028                                                }
6029                                                break;
6030                                        case 10:
6031                                                {
6032                                                setState(754);
6033                                                dt();
6034                                                }
6035                                                break;
6036                                        case 11:
6037                                                {
6038                                                setState(755);
6039                                                head();
6040                                                }
6041                                                break;
6042                                        case 12:
6043                                                {
6044                                                setState(756);
6045                                                html();
6046                                                }
6047                                                break;
6048                                        case 13:
6049                                                {
6050                                                setState(757);
6051                                                option();
6052                                                }
6053                                                break;
6054                                        case 14:
6055                                                {
6056                                                setState(758);
6057                                                tbody();
6058                                                }
6059                                                break;
6060                                        case 15:
6061                                                {
6062                                                setState(759);
6063                                                thead();
6064                                                }
6065                                                break;
6066                                        case 16:
6067                                                {
6068                                                setState(760);
6069                                                tfoot();
6070                                                }
6071                                                break;
6072                                        case 17:
6073                                                {
6074                                                setState(761);
6075                                                pTagOpen();
6076                                                }
6077                                                break;
6078                                        case 18:
6079                                                {
6080                                                setState(762);
6081                                                liTagOpen();
6082                                                }
6083                                                break;
6084                                        case 19:
6085                                                {
6086                                                setState(763);
6087                                                trTagOpen();
6088                                                }
6089                                                break;
6090                                        case 20:
6091                                                {
6092                                                setState(764);
6093                                                tdTagOpen();
6094                                                }
6095                                                break;
6096                                        case 21:
6097                                                {
6098                                                setState(765);
6099                                                thTagOpen();
6100                                                }
6101                                                break;
6102                                        case 22:
6103                                                {
6104                                                setState(766);
6105                                                bodyTagOpen();
6106                                                }
6107                                                break;
6108                                        case 23:
6109                                                {
6110                                                setState(767);
6111                                                ddTagOpen();
6112                                                }
6113                                                break;
6114                                        case 24:
6115                                                {
6116                                                setState(768);
6117                                                dtTagOpen();
6118                                                }
6119                                                break;
6120                                        case 25:
6121                                                {
6122                                                setState(769);
6123                                                headTagOpen();
6124                                                }
6125                                                break;
6126                                        case 26:
6127                                                {
6128                                                setState(770);
6129                                                htmlTagOpen();
6130                                                }
6131                                                break;
6132                                        case 27:
6133                                                {
6134                                                setState(771);
6135                                                optionTagOpen();
6136                                                }
6137                                                break;
6138                                        case 28:
6139                                                {
6140                                                setState(772);
6141                                                tbodyTagOpen();
6142                                                }
6143                                                break;
6144                                        case 29:
6145                                                {
6146                                                setState(773);
6147                                                theadTagOpen();
6148                                                }
6149                                                break;
6150                                        case 30:
6151                                                {
6152                                                setState(774);
6153                                                tfootTagOpen();
6154                                                }
6155                                                break;
6156                                        case 31:
6157                                                {
6158                                                {
6159                                                setState(775);
6160                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6161                                                setState(776);
6162                                                match(LEADING_ASTERISK);
6163                                                }
6164                                                }
6165                                                break;
6166                                        case 32:
6167                                                {
6168                                                setState(777);
6169                                                htmlComment();
6170                                                }
6171                                                break;
6172                                        case 33:
6173                                                {
6174                                                setState(778);
6175                                                match(CDATA);
6176                                                }
6177                                                break;
6178                                        case 34:
6179                                                {
6180                                                setState(779);
6181                                                match(NEWLINE);
6182                                                }
6183                                                break;
6184                                        case 35:
6185                                                {
6186                                                setState(780);
6187                                                text();
6188                                                }
6189                                                break;
6190                                        case 36:
6191                                                {
6192                                                setState(781);
6193                                                javadocInlineTag();
6194                                                }
6195                                                break;
6196                                        }
6197                                        } 
6198                                }
6199                                setState(786);
6200                                _errHandler.sync(this);
6201                                _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6202                        }
6203                        setState(787);
6204                        colgroupTagClose();
6205                        }
6206                }
6207                catch (RecognitionException re) {
6208                        _localctx.exception = re;
6209                        _errHandler.reportError(this, re);
6210                        _errHandler.recover(this, re);
6211                }
6212                finally {
6213                        exitRule();
6214                }
6215                return _localctx;
6216        }
6217
6218        public static class DdTagOpenContext extends ParserRuleContext {
6219                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6220                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6221                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6222                public List<AttributeContext> attribute() {
6223                        return getRuleContexts(AttributeContext.class);
6224                }
6225                public AttributeContext attribute(int i) {
6226                        return getRuleContext(AttributeContext.class,i);
6227                }
6228                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6229                public TerminalNode NEWLINE(int i) {
6230                        return getToken(JavadocParser.NEWLINE, i);
6231                }
6232                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6233                public TerminalNode LEADING_ASTERISK(int i) {
6234                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6235                }
6236                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6237                public TerminalNode WS(int i) {
6238                        return getToken(JavadocParser.WS, i);
6239                }
6240                public DdTagOpenContext(ParserRuleContext parent, int invokingState) {
6241                        super(parent, invokingState);
6242                }
6243                @Override public int getRuleIndex() { return RULE_ddTagOpen; }
6244                @Override
6245                public void enterRule(ParseTreeListener listener) {
6246                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this);
6247                }
6248                @Override
6249                public void exitRule(ParseTreeListener listener) {
6250                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this);
6251                }
6252                @Override
6253                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6254                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this);
6255                        else return visitor.visitChildren(this);
6256                }
6257        }
6258
6259        public final DdTagOpenContext ddTagOpen() throws RecognitionException {
6260                DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState());
6261                enterRule(_localctx, 54, RULE_ddTagOpen);
6262                int _la;
6263                try {
6264                        enterOuterAlt(_localctx, 1);
6265                        {
6266                        setState(789);
6267                        match(OPEN);
6268                        setState(790);
6269                        match(DD_HTML_TAG_NAME);
6270                        setState(797);
6271                        _errHandler.sync(this);
6272                        _la = _input.LA(1);
6273                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6274                                {
6275                                setState(795);
6276                                switch (_input.LA(1)) {
6277                                case HTML_TAG_NAME:
6278                                        {
6279                                        setState(791);
6280                                        attribute();
6281                                        }
6282                                        break;
6283                                case NEWLINE:
6284                                        {
6285                                        setState(792);
6286                                        match(NEWLINE);
6287                                        }
6288                                        break;
6289                                case LEADING_ASTERISK:
6290                                        {
6291                                        setState(793);
6292                                        match(LEADING_ASTERISK);
6293                                        }
6294                                        break;
6295                                case WS:
6296                                        {
6297                                        setState(794);
6298                                        match(WS);
6299                                        }
6300                                        break;
6301                                default:
6302                                        throw new NoViableAltException(this);
6303                                }
6304                                }
6305                                setState(799);
6306                                _errHandler.sync(this);
6307                                _la = _input.LA(1);
6308                        }
6309                        setState(800);
6310                        match(CLOSE);
6311                        }
6312                }
6313                catch (RecognitionException re) {
6314                        _localctx.exception = re;
6315                        _errHandler.reportError(this, re);
6316                        _errHandler.recover(this, re);
6317                }
6318                finally {
6319                        exitRule();
6320                }
6321                return _localctx;
6322        }
6323
6324        public static class DdTagCloseContext extends ParserRuleContext {
6325                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6326                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6327                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6328                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6329                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6330                public TerminalNode NEWLINE(int i) {
6331                        return getToken(JavadocParser.NEWLINE, i);
6332                }
6333                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6334                public TerminalNode LEADING_ASTERISK(int i) {
6335                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6336                }
6337                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6338                public TerminalNode WS(int i) {
6339                        return getToken(JavadocParser.WS, i);
6340                }
6341                public DdTagCloseContext(ParserRuleContext parent, int invokingState) {
6342                        super(parent, invokingState);
6343                }
6344                @Override public int getRuleIndex() { return RULE_ddTagClose; }
6345                @Override
6346                public void enterRule(ParseTreeListener listener) {
6347                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this);
6348                }
6349                @Override
6350                public void exitRule(ParseTreeListener listener) {
6351                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this);
6352                }
6353                @Override
6354                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6355                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this);
6356                        else return visitor.visitChildren(this);
6357                }
6358        }
6359
6360        public final DdTagCloseContext ddTagClose() throws RecognitionException {
6361                DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState());
6362                enterRule(_localctx, 56, RULE_ddTagClose);
6363                int _la;
6364                try {
6365                        enterOuterAlt(_localctx, 1);
6366                        {
6367                        setState(802);
6368                        match(OPEN);
6369                        setState(803);
6370                        match(SLASH);
6371                        setState(804);
6372                        match(DD_HTML_TAG_NAME);
6373                        setState(808);
6374                        _errHandler.sync(this);
6375                        _la = _input.LA(1);
6376                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6377                                {
6378                                {
6379                                setState(805);
6380                                _la = _input.LA(1);
6381                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6382                                _errHandler.recoverInline(this);
6383                                } else {
6384                                        consume();
6385                                }
6386                                }
6387                                }
6388                                setState(810);
6389                                _errHandler.sync(this);
6390                                _la = _input.LA(1);
6391                        }
6392                        setState(811);
6393                        match(CLOSE);
6394                        }
6395                }
6396                catch (RecognitionException re) {
6397                        _localctx.exception = re;
6398                        _errHandler.reportError(this, re);
6399                        _errHandler.recover(this, re);
6400                }
6401                finally {
6402                        exitRule();
6403                }
6404                return _localctx;
6405        }
6406
6407        public static class DdContext extends ParserRuleContext {
6408                public DdTagOpenContext ddTagOpen() {
6409                        return getRuleContext(DdTagOpenContext.class,0);
6410                }
6411                public DdTagCloseContext ddTagClose() {
6412                        return getRuleContext(DdTagCloseContext.class,0);
6413                }
6414                public List<HtmlTagContext> htmlTag() {
6415                        return getRuleContexts(HtmlTagContext.class);
6416                }
6417                public HtmlTagContext htmlTag(int i) {
6418                        return getRuleContext(HtmlTagContext.class,i);
6419                }
6420                public List<SingletonTagContext> singletonTag() {
6421                        return getRuleContexts(SingletonTagContext.class);
6422                }
6423                public SingletonTagContext singletonTag(int i) {
6424                        return getRuleContext(SingletonTagContext.class,i);
6425                }
6426                public List<ParagraphContext> paragraph() {
6427                        return getRuleContexts(ParagraphContext.class);
6428                }
6429                public ParagraphContext paragraph(int i) {
6430                        return getRuleContext(ParagraphContext.class,i);
6431                }
6432                public List<LiContext> li() {
6433                        return getRuleContexts(LiContext.class);
6434                }
6435                public LiContext li(int i) {
6436                        return getRuleContext(LiContext.class,i);
6437                }
6438                public List<TrContext> tr() {
6439                        return getRuleContexts(TrContext.class);
6440                }
6441                public TrContext tr(int i) {
6442                        return getRuleContext(TrContext.class,i);
6443                }
6444                public List<TdContext> td() {
6445                        return getRuleContexts(TdContext.class);
6446                }
6447                public TdContext td(int i) {
6448                        return getRuleContext(TdContext.class,i);
6449                }
6450                public List<ThContext> th() {
6451                        return getRuleContexts(ThContext.class);
6452                }
6453                public ThContext th(int i) {
6454                        return getRuleContext(ThContext.class,i);
6455                }
6456                public List<BodyContext> body() {
6457                        return getRuleContexts(BodyContext.class);
6458                }
6459                public BodyContext body(int i) {
6460                        return getRuleContext(BodyContext.class,i);
6461                }
6462                public List<ColgroupContext> colgroup() {
6463                        return getRuleContexts(ColgroupContext.class);
6464                }
6465                public ColgroupContext colgroup(int i) {
6466                        return getRuleContext(ColgroupContext.class,i);
6467                }
6468                public List<DtContext> dt() {
6469                        return getRuleContexts(DtContext.class);
6470                }
6471                public DtContext dt(int i) {
6472                        return getRuleContext(DtContext.class,i);
6473                }
6474                public List<HeadContext> head() {
6475                        return getRuleContexts(HeadContext.class);
6476                }
6477                public HeadContext head(int i) {
6478                        return getRuleContext(HeadContext.class,i);
6479                }
6480                public List<HtmlContext> html() {
6481                        return getRuleContexts(HtmlContext.class);
6482                }
6483                public HtmlContext html(int i) {
6484                        return getRuleContext(HtmlContext.class,i);
6485                }
6486                public List<OptionContext> option() {
6487                        return getRuleContexts(OptionContext.class);
6488                }
6489                public OptionContext option(int i) {
6490                        return getRuleContext(OptionContext.class,i);
6491                }
6492                public List<TbodyContext> tbody() {
6493                        return getRuleContexts(TbodyContext.class);
6494                }
6495                public TbodyContext tbody(int i) {
6496                        return getRuleContext(TbodyContext.class,i);
6497                }
6498                public List<TheadContext> thead() {
6499                        return getRuleContexts(TheadContext.class);
6500                }
6501                public TheadContext thead(int i) {
6502                        return getRuleContext(TheadContext.class,i);
6503                }
6504                public List<TfootContext> tfoot() {
6505                        return getRuleContexts(TfootContext.class);
6506                }
6507                public TfootContext tfoot(int i) {
6508                        return getRuleContext(TfootContext.class,i);
6509                }
6510                public List<PTagOpenContext> pTagOpen() {
6511                        return getRuleContexts(PTagOpenContext.class);
6512                }
6513                public PTagOpenContext pTagOpen(int i) {
6514                        return getRuleContext(PTagOpenContext.class,i);
6515                }
6516                public List<LiTagOpenContext> liTagOpen() {
6517                        return getRuleContexts(LiTagOpenContext.class);
6518                }
6519                public LiTagOpenContext liTagOpen(int i) {
6520                        return getRuleContext(LiTagOpenContext.class,i);
6521                }
6522                public List<TrTagOpenContext> trTagOpen() {
6523                        return getRuleContexts(TrTagOpenContext.class);
6524                }
6525                public TrTagOpenContext trTagOpen(int i) {
6526                        return getRuleContext(TrTagOpenContext.class,i);
6527                }
6528                public List<TdTagOpenContext> tdTagOpen() {
6529                        return getRuleContexts(TdTagOpenContext.class);
6530                }
6531                public TdTagOpenContext tdTagOpen(int i) {
6532                        return getRuleContext(TdTagOpenContext.class,i);
6533                }
6534                public List<ThTagOpenContext> thTagOpen() {
6535                        return getRuleContexts(ThTagOpenContext.class);
6536                }
6537                public ThTagOpenContext thTagOpen(int i) {
6538                        return getRuleContext(ThTagOpenContext.class,i);
6539                }
6540                public List<BodyTagOpenContext> bodyTagOpen() {
6541                        return getRuleContexts(BodyTagOpenContext.class);
6542                }
6543                public BodyTagOpenContext bodyTagOpen(int i) {
6544                        return getRuleContext(BodyTagOpenContext.class,i);
6545                }
6546                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6547                        return getRuleContexts(ColgroupTagOpenContext.class);
6548                }
6549                public ColgroupTagOpenContext colgroupTagOpen(int i) {
6550                        return getRuleContext(ColgroupTagOpenContext.class,i);
6551                }
6552                public List<DtTagOpenContext> dtTagOpen() {
6553                        return getRuleContexts(DtTagOpenContext.class);
6554                }
6555                public DtTagOpenContext dtTagOpen(int i) {
6556                        return getRuleContext(DtTagOpenContext.class,i);
6557                }
6558                public List<HeadTagOpenContext> headTagOpen() {
6559                        return getRuleContexts(HeadTagOpenContext.class);
6560                }
6561                public HeadTagOpenContext headTagOpen(int i) {
6562                        return getRuleContext(HeadTagOpenContext.class,i);
6563                }
6564                public List<HtmlTagOpenContext> htmlTagOpen() {
6565                        return getRuleContexts(HtmlTagOpenContext.class);
6566                }
6567                public HtmlTagOpenContext htmlTagOpen(int i) {
6568                        return getRuleContext(HtmlTagOpenContext.class,i);
6569                }
6570                public List<OptionTagOpenContext> optionTagOpen() {
6571                        return getRuleContexts(OptionTagOpenContext.class);
6572                }
6573                public OptionTagOpenContext optionTagOpen(int i) {
6574                        return getRuleContext(OptionTagOpenContext.class,i);
6575                }
6576                public List<TbodyTagOpenContext> tbodyTagOpen() {
6577                        return getRuleContexts(TbodyTagOpenContext.class);
6578                }
6579                public TbodyTagOpenContext tbodyTagOpen(int i) {
6580                        return getRuleContext(TbodyTagOpenContext.class,i);
6581                }
6582                public List<TheadTagOpenContext> theadTagOpen() {
6583                        return getRuleContexts(TheadTagOpenContext.class);
6584                }
6585                public TheadTagOpenContext theadTagOpen(int i) {
6586                        return getRuleContext(TheadTagOpenContext.class,i);
6587                }
6588                public List<TfootTagOpenContext> tfootTagOpen() {
6589                        return getRuleContexts(TfootTagOpenContext.class);
6590                }
6591                public TfootTagOpenContext tfootTagOpen(int i) {
6592                        return getRuleContext(TfootTagOpenContext.class,i);
6593                }
6594                public List<HtmlCommentContext> htmlComment() {
6595                        return getRuleContexts(HtmlCommentContext.class);
6596                }
6597                public HtmlCommentContext htmlComment(int i) {
6598                        return getRuleContext(HtmlCommentContext.class,i);
6599                }
6600                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6601                public TerminalNode CDATA(int i) {
6602                        return getToken(JavadocParser.CDATA, i);
6603                }
6604                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6605                public TerminalNode NEWLINE(int i) {
6606                        return getToken(JavadocParser.NEWLINE, i);
6607                }
6608                public List<TextContext> text() {
6609                        return getRuleContexts(TextContext.class);
6610                }
6611                public TextContext text(int i) {
6612                        return getRuleContext(TextContext.class,i);
6613                }
6614                public List<JavadocInlineTagContext> javadocInlineTag() {
6615                        return getRuleContexts(JavadocInlineTagContext.class);
6616                }
6617                public JavadocInlineTagContext javadocInlineTag(int i) {
6618                        return getRuleContext(JavadocInlineTagContext.class,i);
6619                }
6620                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6621                public TerminalNode LEADING_ASTERISK(int i) {
6622                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6623                }
6624                public DdContext(ParserRuleContext parent, int invokingState) {
6625                        super(parent, invokingState);
6626                }
6627                @Override public int getRuleIndex() { return RULE_dd; }
6628                @Override
6629                public void enterRule(ParseTreeListener listener) {
6630                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this);
6631                }
6632                @Override
6633                public void exitRule(ParseTreeListener listener) {
6634                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this);
6635                }
6636                @Override
6637                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6638                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this);
6639                        else return visitor.visitChildren(this);
6640                }
6641        }
6642
6643        public final DdContext dd() throws RecognitionException {
6644                DdContext _localctx = new DdContext(_ctx, getState());
6645                enterRule(_localctx, 58, RULE_dd);
6646                try {
6647                        int _alt;
6648                        enterOuterAlt(_localctx, 1);
6649                        {
6650                        setState(813);
6651                        ddTagOpen();
6652                        setState(853);
6653                        _errHandler.sync(this);
6654                        _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6655                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6656                                if ( _alt==1 ) {
6657                                        {
6658                                        setState(851);
6659                                        switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
6660                                        case 1:
6661                                                {
6662                                                setState(814);
6663                                                htmlTag();
6664                                                }
6665                                                break;
6666                                        case 2:
6667                                                {
6668                                                setState(815);
6669                                                singletonTag();
6670                                                }
6671                                                break;
6672                                        case 3:
6673                                                {
6674                                                setState(816);
6675                                                paragraph();
6676                                                }
6677                                                break;
6678                                        case 4:
6679                                                {
6680                                                setState(817);
6681                                                li();
6682                                                }
6683                                                break;
6684                                        case 5:
6685                                                {
6686                                                setState(818);
6687                                                tr();
6688                                                }
6689                                                break;
6690                                        case 6:
6691                                                {
6692                                                setState(819);
6693                                                td();
6694                                                }
6695                                                break;
6696                                        case 7:
6697                                                {
6698                                                setState(820);
6699                                                th();
6700                                                }
6701                                                break;
6702                                        case 8:
6703                                                {
6704                                                setState(821);
6705                                                body();
6706                                                }
6707                                                break;
6708                                        case 9:
6709                                                {
6710                                                setState(822);
6711                                                colgroup();
6712                                                }
6713                                                break;
6714                                        case 10:
6715                                                {
6716                                                setState(823);
6717                                                dt();
6718                                                }
6719                                                break;
6720                                        case 11:
6721                                                {
6722                                                setState(824);
6723                                                head();
6724                                                }
6725                                                break;
6726                                        case 12:
6727                                                {
6728                                                setState(825);
6729                                                html();
6730                                                }
6731                                                break;
6732                                        case 13:
6733                                                {
6734                                                setState(826);
6735                                                option();
6736                                                }
6737                                                break;
6738                                        case 14:
6739                                                {
6740                                                setState(827);
6741                                                tbody();
6742                                                }
6743                                                break;
6744                                        case 15:
6745                                                {
6746                                                setState(828);
6747                                                thead();
6748                                                }
6749                                                break;
6750                                        case 16:
6751                                                {
6752                                                setState(829);
6753                                                tfoot();
6754                                                }
6755                                                break;
6756                                        case 17:
6757                                                {
6758                                                setState(830);
6759                                                pTagOpen();
6760                                                }
6761                                                break;
6762                                        case 18:
6763                                                {
6764                                                setState(831);
6765                                                liTagOpen();
6766                                                }
6767                                                break;
6768                                        case 19:
6769                                                {
6770                                                setState(832);
6771                                                trTagOpen();
6772                                                }
6773                                                break;
6774                                        case 20:
6775                                                {
6776                                                setState(833);
6777                                                tdTagOpen();
6778                                                }
6779                                                break;
6780                                        case 21:
6781                                                {
6782                                                setState(834);
6783                                                thTagOpen();
6784                                                }
6785                                                break;
6786                                        case 22:
6787                                                {
6788                                                setState(835);
6789                                                bodyTagOpen();
6790                                                }
6791                                                break;
6792                                        case 23:
6793                                                {
6794                                                setState(836);
6795                                                colgroupTagOpen();
6796                                                }
6797                                                break;
6798                                        case 24:
6799                                                {
6800                                                setState(837);
6801                                                dtTagOpen();
6802                                                }
6803                                                break;
6804                                        case 25:
6805                                                {
6806                                                setState(838);
6807                                                headTagOpen();
6808                                                }
6809                                                break;
6810                                        case 26:
6811                                                {
6812                                                setState(839);
6813                                                htmlTagOpen();
6814                                                }
6815                                                break;
6816                                        case 27:
6817                                                {
6818                                                setState(840);
6819                                                optionTagOpen();
6820                                                }
6821                                                break;
6822                                        case 28:
6823                                                {
6824                                                setState(841);
6825                                                tbodyTagOpen();
6826                                                }
6827                                                break;
6828                                        case 29:
6829                                                {
6830                                                setState(842);
6831                                                theadTagOpen();
6832                                                }
6833                                                break;
6834                                        case 30:
6835                                                {
6836                                                setState(843);
6837                                                tfootTagOpen();
6838                                                }
6839                                                break;
6840                                        case 31:
6841                                                {
6842                                                {
6843                                                setState(844);
6844                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6845                                                setState(845);
6846                                                match(LEADING_ASTERISK);
6847                                                }
6848                                                }
6849                                                break;
6850                                        case 32:
6851                                                {
6852                                                setState(846);
6853                                                htmlComment();
6854                                                }
6855                                                break;
6856                                        case 33:
6857                                                {
6858                                                setState(847);
6859                                                match(CDATA);
6860                                                }
6861                                                break;
6862                                        case 34:
6863                                                {
6864                                                setState(848);
6865                                                match(NEWLINE);
6866                                                }
6867                                                break;
6868                                        case 35:
6869                                                {
6870                                                setState(849);
6871                                                text();
6872                                                }
6873                                                break;
6874                                        case 36:
6875                                                {
6876                                                setState(850);
6877                                                javadocInlineTag();
6878                                                }
6879                                                break;
6880                                        }
6881                                        } 
6882                                }
6883                                setState(855);
6884                                _errHandler.sync(this);
6885                                _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6886                        }
6887                        setState(856);
6888                        ddTagClose();
6889                        }
6890                }
6891                catch (RecognitionException re) {
6892                        _localctx.exception = re;
6893                        _errHandler.reportError(this, re);
6894                        _errHandler.recover(this, re);
6895                }
6896                finally {
6897                        exitRule();
6898                }
6899                return _localctx;
6900        }
6901
6902        public static class DtTagOpenContext extends ParserRuleContext {
6903                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6904                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6905                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6906                public List<AttributeContext> attribute() {
6907                        return getRuleContexts(AttributeContext.class);
6908                }
6909                public AttributeContext attribute(int i) {
6910                        return getRuleContext(AttributeContext.class,i);
6911                }
6912                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6913                public TerminalNode NEWLINE(int i) {
6914                        return getToken(JavadocParser.NEWLINE, i);
6915                }
6916                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6917                public TerminalNode LEADING_ASTERISK(int i) {
6918                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6919                }
6920                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6921                public TerminalNode WS(int i) {
6922                        return getToken(JavadocParser.WS, i);
6923                }
6924                public DtTagOpenContext(ParserRuleContext parent, int invokingState) {
6925                        super(parent, invokingState);
6926                }
6927                @Override public int getRuleIndex() { return RULE_dtTagOpen; }
6928                @Override
6929                public void enterRule(ParseTreeListener listener) {
6930                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this);
6931                }
6932                @Override
6933                public void exitRule(ParseTreeListener listener) {
6934                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this);
6935                }
6936                @Override
6937                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6938                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this);
6939                        else return visitor.visitChildren(this);
6940                }
6941        }
6942
6943        public final DtTagOpenContext dtTagOpen() throws RecognitionException {
6944                DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState());
6945                enterRule(_localctx, 60, RULE_dtTagOpen);
6946                int _la;
6947                try {
6948                        enterOuterAlt(_localctx, 1);
6949                        {
6950                        setState(858);
6951                        match(OPEN);
6952                        setState(859);
6953                        match(DT_HTML_TAG_NAME);
6954                        setState(866);
6955                        _errHandler.sync(this);
6956                        _la = _input.LA(1);
6957                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6958                                {
6959                                setState(864);
6960                                switch (_input.LA(1)) {
6961                                case HTML_TAG_NAME:
6962                                        {
6963                                        setState(860);
6964                                        attribute();
6965                                        }
6966                                        break;
6967                                case NEWLINE:
6968                                        {
6969                                        setState(861);
6970                                        match(NEWLINE);
6971                                        }
6972                                        break;
6973                                case LEADING_ASTERISK:
6974                                        {
6975                                        setState(862);
6976                                        match(LEADING_ASTERISK);
6977                                        }
6978                                        break;
6979                                case WS:
6980                                        {
6981                                        setState(863);
6982                                        match(WS);
6983                                        }
6984                                        break;
6985                                default:
6986                                        throw new NoViableAltException(this);
6987                                }
6988                                }
6989                                setState(868);
6990                                _errHandler.sync(this);
6991                                _la = _input.LA(1);
6992                        }
6993                        setState(869);
6994                        match(CLOSE);
6995                        }
6996                }
6997                catch (RecognitionException re) {
6998                        _localctx.exception = re;
6999                        _errHandler.reportError(this, re);
7000                        _errHandler.recover(this, re);
7001                }
7002                finally {
7003                        exitRule();
7004                }
7005                return _localctx;
7006        }
7007
7008        public static class DtTagCloseContext extends ParserRuleContext {
7009                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7010                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7011                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
7012                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7013                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7014                public TerminalNode NEWLINE(int i) {
7015                        return getToken(JavadocParser.NEWLINE, i);
7016                }
7017                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7018                public TerminalNode LEADING_ASTERISK(int i) {
7019                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7020                }
7021                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7022                public TerminalNode WS(int i) {
7023                        return getToken(JavadocParser.WS, i);
7024                }
7025                public DtTagCloseContext(ParserRuleContext parent, int invokingState) {
7026                        super(parent, invokingState);
7027                }
7028                @Override public int getRuleIndex() { return RULE_dtTagClose; }
7029                @Override
7030                public void enterRule(ParseTreeListener listener) {
7031                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this);
7032                }
7033                @Override
7034                public void exitRule(ParseTreeListener listener) {
7035                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this);
7036                }
7037                @Override
7038                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7039                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this);
7040                        else return visitor.visitChildren(this);
7041                }
7042        }
7043
7044        public final DtTagCloseContext dtTagClose() throws RecognitionException {
7045                DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState());
7046                enterRule(_localctx, 62, RULE_dtTagClose);
7047                int _la;
7048                try {
7049                        enterOuterAlt(_localctx, 1);
7050                        {
7051                        setState(871);
7052                        match(OPEN);
7053                        setState(872);
7054                        match(SLASH);
7055                        setState(873);
7056                        match(DT_HTML_TAG_NAME);
7057                        setState(877);
7058                        _errHandler.sync(this);
7059                        _la = _input.LA(1);
7060                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7061                                {
7062                                {
7063                                setState(874);
7064                                _la = _input.LA(1);
7065                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7066                                _errHandler.recoverInline(this);
7067                                } else {
7068                                        consume();
7069                                }
7070                                }
7071                                }
7072                                setState(879);
7073                                _errHandler.sync(this);
7074                                _la = _input.LA(1);
7075                        }
7076                        setState(880);
7077                        match(CLOSE);
7078                        }
7079                }
7080                catch (RecognitionException re) {
7081                        _localctx.exception = re;
7082                        _errHandler.reportError(this, re);
7083                        _errHandler.recover(this, re);
7084                }
7085                finally {
7086                        exitRule();
7087                }
7088                return _localctx;
7089        }
7090
7091        public static class DtContext extends ParserRuleContext {
7092                public DtTagOpenContext dtTagOpen() {
7093                        return getRuleContext(DtTagOpenContext.class,0);
7094                }
7095                public DtTagCloseContext dtTagClose() {
7096                        return getRuleContext(DtTagCloseContext.class,0);
7097                }
7098                public List<HtmlTagContext> htmlTag() {
7099                        return getRuleContexts(HtmlTagContext.class);
7100                }
7101                public HtmlTagContext htmlTag(int i) {
7102                        return getRuleContext(HtmlTagContext.class,i);
7103                }
7104                public List<SingletonTagContext> singletonTag() {
7105                        return getRuleContexts(SingletonTagContext.class);
7106                }
7107                public SingletonTagContext singletonTag(int i) {
7108                        return getRuleContext(SingletonTagContext.class,i);
7109                }
7110                public List<ParagraphContext> paragraph() {
7111                        return getRuleContexts(ParagraphContext.class);
7112                }
7113                public ParagraphContext paragraph(int i) {
7114                        return getRuleContext(ParagraphContext.class,i);
7115                }
7116                public List<LiContext> li() {
7117                        return getRuleContexts(LiContext.class);
7118                }
7119                public LiContext li(int i) {
7120                        return getRuleContext(LiContext.class,i);
7121                }
7122                public List<TrContext> tr() {
7123                        return getRuleContexts(TrContext.class);
7124                }
7125                public TrContext tr(int i) {
7126                        return getRuleContext(TrContext.class,i);
7127                }
7128                public List<TdContext> td() {
7129                        return getRuleContexts(TdContext.class);
7130                }
7131                public TdContext td(int i) {
7132                        return getRuleContext(TdContext.class,i);
7133                }
7134                public List<ThContext> th() {
7135                        return getRuleContexts(ThContext.class);
7136                }
7137                public ThContext th(int i) {
7138                        return getRuleContext(ThContext.class,i);
7139                }
7140                public List<BodyContext> body() {
7141                        return getRuleContexts(BodyContext.class);
7142                }
7143                public BodyContext body(int i) {
7144                        return getRuleContext(BodyContext.class,i);
7145                }
7146                public List<ColgroupContext> colgroup() {
7147                        return getRuleContexts(ColgroupContext.class);
7148                }
7149                public ColgroupContext colgroup(int i) {
7150                        return getRuleContext(ColgroupContext.class,i);
7151                }
7152                public List<DdContext> dd() {
7153                        return getRuleContexts(DdContext.class);
7154                }
7155                public DdContext dd(int i) {
7156                        return getRuleContext(DdContext.class,i);
7157                }
7158                public List<HeadContext> head() {
7159                        return getRuleContexts(HeadContext.class);
7160                }
7161                public HeadContext head(int i) {
7162                        return getRuleContext(HeadContext.class,i);
7163                }
7164                public List<HtmlContext> html() {
7165                        return getRuleContexts(HtmlContext.class);
7166                }
7167                public HtmlContext html(int i) {
7168                        return getRuleContext(HtmlContext.class,i);
7169                }
7170                public List<OptionContext> option() {
7171                        return getRuleContexts(OptionContext.class);
7172                }
7173                public OptionContext option(int i) {
7174                        return getRuleContext(OptionContext.class,i);
7175                }
7176                public List<TbodyContext> tbody() {
7177                        return getRuleContexts(TbodyContext.class);
7178                }
7179                public TbodyContext tbody(int i) {
7180                        return getRuleContext(TbodyContext.class,i);
7181                }
7182                public List<TheadContext> thead() {
7183                        return getRuleContexts(TheadContext.class);
7184                }
7185                public TheadContext thead(int i) {
7186                        return getRuleContext(TheadContext.class,i);
7187                }
7188                public List<TfootContext> tfoot() {
7189                        return getRuleContexts(TfootContext.class);
7190                }
7191                public TfootContext tfoot(int i) {
7192                        return getRuleContext(TfootContext.class,i);
7193                }
7194                public List<PTagOpenContext> pTagOpen() {
7195                        return getRuleContexts(PTagOpenContext.class);
7196                }
7197                public PTagOpenContext pTagOpen(int i) {
7198                        return getRuleContext(PTagOpenContext.class,i);
7199                }
7200                public List<LiTagOpenContext> liTagOpen() {
7201                        return getRuleContexts(LiTagOpenContext.class);
7202                }
7203                public LiTagOpenContext liTagOpen(int i) {
7204                        return getRuleContext(LiTagOpenContext.class,i);
7205                }
7206                public List<TrTagOpenContext> trTagOpen() {
7207                        return getRuleContexts(TrTagOpenContext.class);
7208                }
7209                public TrTagOpenContext trTagOpen(int i) {
7210                        return getRuleContext(TrTagOpenContext.class,i);
7211                }
7212                public List<TdTagOpenContext> tdTagOpen() {
7213                        return getRuleContexts(TdTagOpenContext.class);
7214                }
7215                public TdTagOpenContext tdTagOpen(int i) {
7216                        return getRuleContext(TdTagOpenContext.class,i);
7217                }
7218                public List<ThTagOpenContext> thTagOpen() {
7219                        return getRuleContexts(ThTagOpenContext.class);
7220                }
7221                public ThTagOpenContext thTagOpen(int i) {
7222                        return getRuleContext(ThTagOpenContext.class,i);
7223                }
7224                public List<BodyTagOpenContext> bodyTagOpen() {
7225                        return getRuleContexts(BodyTagOpenContext.class);
7226                }
7227                public BodyTagOpenContext bodyTagOpen(int i) {
7228                        return getRuleContext(BodyTagOpenContext.class,i);
7229                }
7230                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7231                        return getRuleContexts(ColgroupTagOpenContext.class);
7232                }
7233                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7234                        return getRuleContext(ColgroupTagOpenContext.class,i);
7235                }
7236                public List<DdTagOpenContext> ddTagOpen() {
7237                        return getRuleContexts(DdTagOpenContext.class);
7238                }
7239                public DdTagOpenContext ddTagOpen(int i) {
7240                        return getRuleContext(DdTagOpenContext.class,i);
7241                }
7242                public List<HeadTagOpenContext> headTagOpen() {
7243                        return getRuleContexts(HeadTagOpenContext.class);
7244                }
7245                public HeadTagOpenContext headTagOpen(int i) {
7246                        return getRuleContext(HeadTagOpenContext.class,i);
7247                }
7248                public List<HtmlTagOpenContext> htmlTagOpen() {
7249                        return getRuleContexts(HtmlTagOpenContext.class);
7250                }
7251                public HtmlTagOpenContext htmlTagOpen(int i) {
7252                        return getRuleContext(HtmlTagOpenContext.class,i);
7253                }
7254                public List<OptionTagOpenContext> optionTagOpen() {
7255                        return getRuleContexts(OptionTagOpenContext.class);
7256                }
7257                public OptionTagOpenContext optionTagOpen(int i) {
7258                        return getRuleContext(OptionTagOpenContext.class,i);
7259                }
7260                public List<TbodyTagOpenContext> tbodyTagOpen() {
7261                        return getRuleContexts(TbodyTagOpenContext.class);
7262                }
7263                public TbodyTagOpenContext tbodyTagOpen(int i) {
7264                        return getRuleContext(TbodyTagOpenContext.class,i);
7265                }
7266                public List<TheadTagOpenContext> theadTagOpen() {
7267                        return getRuleContexts(TheadTagOpenContext.class);
7268                }
7269                public TheadTagOpenContext theadTagOpen(int i) {
7270                        return getRuleContext(TheadTagOpenContext.class,i);
7271                }
7272                public List<TfootTagOpenContext> tfootTagOpen() {
7273                        return getRuleContexts(TfootTagOpenContext.class);
7274                }
7275                public TfootTagOpenContext tfootTagOpen(int i) {
7276                        return getRuleContext(TfootTagOpenContext.class,i);
7277                }
7278                public List<HtmlCommentContext> htmlComment() {
7279                        return getRuleContexts(HtmlCommentContext.class);
7280                }
7281                public HtmlCommentContext htmlComment(int i) {
7282                        return getRuleContext(HtmlCommentContext.class,i);
7283                }
7284                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7285                public TerminalNode CDATA(int i) {
7286                        return getToken(JavadocParser.CDATA, i);
7287                }
7288                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7289                public TerminalNode NEWLINE(int i) {
7290                        return getToken(JavadocParser.NEWLINE, i);
7291                }
7292                public List<TextContext> text() {
7293                        return getRuleContexts(TextContext.class);
7294                }
7295                public TextContext text(int i) {
7296                        return getRuleContext(TextContext.class,i);
7297                }
7298                public List<JavadocInlineTagContext> javadocInlineTag() {
7299                        return getRuleContexts(JavadocInlineTagContext.class);
7300                }
7301                public JavadocInlineTagContext javadocInlineTag(int i) {
7302                        return getRuleContext(JavadocInlineTagContext.class,i);
7303                }
7304                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7305                public TerminalNode LEADING_ASTERISK(int i) {
7306                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7307                }
7308                public DtContext(ParserRuleContext parent, int invokingState) {
7309                        super(parent, invokingState);
7310                }
7311                @Override public int getRuleIndex() { return RULE_dt; }
7312                @Override
7313                public void enterRule(ParseTreeListener listener) {
7314                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this);
7315                }
7316                @Override
7317                public void exitRule(ParseTreeListener listener) {
7318                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this);
7319                }
7320                @Override
7321                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7322                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this);
7323                        else return visitor.visitChildren(this);
7324                }
7325        }
7326
7327        public final DtContext dt() throws RecognitionException {
7328                DtContext _localctx = new DtContext(_ctx, getState());
7329                enterRule(_localctx, 64, RULE_dt);
7330                try {
7331                        int _alt;
7332                        enterOuterAlt(_localctx, 1);
7333                        {
7334                        setState(882);
7335                        dtTagOpen();
7336                        setState(922);
7337                        _errHandler.sync(this);
7338                        _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7339                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7340                                if ( _alt==1 ) {
7341                                        {
7342                                        setState(920);
7343                                        switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
7344                                        case 1:
7345                                                {
7346                                                setState(883);
7347                                                htmlTag();
7348                                                }
7349                                                break;
7350                                        case 2:
7351                                                {
7352                                                setState(884);
7353                                                singletonTag();
7354                                                }
7355                                                break;
7356                                        case 3:
7357                                                {
7358                                                setState(885);
7359                                                paragraph();
7360                                                }
7361                                                break;
7362                                        case 4:
7363                                                {
7364                                                setState(886);
7365                                                li();
7366                                                }
7367                                                break;
7368                                        case 5:
7369                                                {
7370                                                setState(887);
7371                                                tr();
7372                                                }
7373                                                break;
7374                                        case 6:
7375                                                {
7376                                                setState(888);
7377                                                td();
7378                                                }
7379                                                break;
7380                                        case 7:
7381                                                {
7382                                                setState(889);
7383                                                th();
7384                                                }
7385                                                break;
7386                                        case 8:
7387                                                {
7388                                                setState(890);
7389                                                body();
7390                                                }
7391                                                break;
7392                                        case 9:
7393                                                {
7394                                                setState(891);
7395                                                colgroup();
7396                                                }
7397                                                break;
7398                                        case 10:
7399                                                {
7400                                                setState(892);
7401                                                dd();
7402                                                }
7403                                                break;
7404                                        case 11:
7405                                                {
7406                                                setState(893);
7407                                                head();
7408                                                }
7409                                                break;
7410                                        case 12:
7411                                                {
7412                                                setState(894);
7413                                                html();
7414                                                }
7415                                                break;
7416                                        case 13:
7417                                                {
7418                                                setState(895);
7419                                                option();
7420                                                }
7421                                                break;
7422                                        case 14:
7423                                                {
7424                                                setState(896);
7425                                                tbody();
7426                                                }
7427                                                break;
7428                                        case 15:
7429                                                {
7430                                                setState(897);
7431                                                thead();
7432                                                }
7433                                                break;
7434                                        case 16:
7435                                                {
7436                                                setState(898);
7437                                                tfoot();
7438                                                }
7439                                                break;
7440                                        case 17:
7441                                                {
7442                                                setState(899);
7443                                                pTagOpen();
7444                                                }
7445                                                break;
7446                                        case 18:
7447                                                {
7448                                                setState(900);
7449                                                liTagOpen();
7450                                                }
7451                                                break;
7452                                        case 19:
7453                                                {
7454                                                setState(901);
7455                                                trTagOpen();
7456                                                }
7457                                                break;
7458                                        case 20:
7459                                                {
7460                                                setState(902);
7461                                                tdTagOpen();
7462                                                }
7463                                                break;
7464                                        case 21:
7465                                                {
7466                                                setState(903);
7467                                                thTagOpen();
7468                                                }
7469                                                break;
7470                                        case 22:
7471                                                {
7472                                                setState(904);
7473                                                bodyTagOpen();
7474                                                }
7475                                                break;
7476                                        case 23:
7477                                                {
7478                                                setState(905);
7479                                                colgroupTagOpen();
7480                                                }
7481                                                break;
7482                                        case 24:
7483                                                {
7484                                                setState(906);
7485                                                ddTagOpen();
7486                                                }
7487                                                break;
7488                                        case 25:
7489                                                {
7490                                                setState(907);
7491                                                headTagOpen();
7492                                                }
7493                                                break;
7494                                        case 26:
7495                                                {
7496                                                setState(908);
7497                                                htmlTagOpen();
7498                                                }
7499                                                break;
7500                                        case 27:
7501                                                {
7502                                                setState(909);
7503                                                optionTagOpen();
7504                                                }
7505                                                break;
7506                                        case 28:
7507                                                {
7508                                                setState(910);
7509                                                tbodyTagOpen();
7510                                                }
7511                                                break;
7512                                        case 29:
7513                                                {
7514                                                setState(911);
7515                                                theadTagOpen();
7516                                                }
7517                                                break;
7518                                        case 30:
7519                                                {
7520                                                setState(912);
7521                                                tfootTagOpen();
7522                                                }
7523                                                break;
7524                                        case 31:
7525                                                {
7526                                                {
7527                                                setState(913);
7528                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7529                                                setState(914);
7530                                                match(LEADING_ASTERISK);
7531                                                }
7532                                                }
7533                                                break;
7534                                        case 32:
7535                                                {
7536                                                setState(915);
7537                                                htmlComment();
7538                                                }
7539                                                break;
7540                                        case 33:
7541                                                {
7542                                                setState(916);
7543                                                match(CDATA);
7544                                                }
7545                                                break;
7546                                        case 34:
7547                                                {
7548                                                setState(917);
7549                                                match(NEWLINE);
7550                                                }
7551                                                break;
7552                                        case 35:
7553                                                {
7554                                                setState(918);
7555                                                text();
7556                                                }
7557                                                break;
7558                                        case 36:
7559                                                {
7560                                                setState(919);
7561                                                javadocInlineTag();
7562                                                }
7563                                                break;
7564                                        }
7565                                        } 
7566                                }
7567                                setState(924);
7568                                _errHandler.sync(this);
7569                                _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7570                        }
7571                        setState(925);
7572                        dtTagClose();
7573                        }
7574                }
7575                catch (RecognitionException re) {
7576                        _localctx.exception = re;
7577                        _errHandler.reportError(this, re);
7578                        _errHandler.recover(this, re);
7579                }
7580                finally {
7581                        exitRule();
7582                }
7583                return _localctx;
7584        }
7585
7586        public static class HeadTagOpenContext extends ParserRuleContext {
7587                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7588                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7589                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7590                public List<AttributeContext> attribute() {
7591                        return getRuleContexts(AttributeContext.class);
7592                }
7593                public AttributeContext attribute(int i) {
7594                        return getRuleContext(AttributeContext.class,i);
7595                }
7596                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7597                public TerminalNode NEWLINE(int i) {
7598                        return getToken(JavadocParser.NEWLINE, i);
7599                }
7600                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7601                public TerminalNode LEADING_ASTERISK(int i) {
7602                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7603                }
7604                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7605                public TerminalNode WS(int i) {
7606                        return getToken(JavadocParser.WS, i);
7607                }
7608                public HeadTagOpenContext(ParserRuleContext parent, int invokingState) {
7609                        super(parent, invokingState);
7610                }
7611                @Override public int getRuleIndex() { return RULE_headTagOpen; }
7612                @Override
7613                public void enterRule(ParseTreeListener listener) {
7614                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this);
7615                }
7616                @Override
7617                public void exitRule(ParseTreeListener listener) {
7618                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this);
7619                }
7620                @Override
7621                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7622                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this);
7623                        else return visitor.visitChildren(this);
7624                }
7625        }
7626
7627        public final HeadTagOpenContext headTagOpen() throws RecognitionException {
7628                HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState());
7629                enterRule(_localctx, 66, RULE_headTagOpen);
7630                int _la;
7631                try {
7632                        enterOuterAlt(_localctx, 1);
7633                        {
7634                        setState(927);
7635                        match(OPEN);
7636                        setState(928);
7637                        match(HEAD_HTML_TAG_NAME);
7638                        setState(935);
7639                        _errHandler.sync(this);
7640                        _la = _input.LA(1);
7641                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7642                                {
7643                                setState(933);
7644                                switch (_input.LA(1)) {
7645                                case HTML_TAG_NAME:
7646                                        {
7647                                        setState(929);
7648                                        attribute();
7649                                        }
7650                                        break;
7651                                case NEWLINE:
7652                                        {
7653                                        setState(930);
7654                                        match(NEWLINE);
7655                                        }
7656                                        break;
7657                                case LEADING_ASTERISK:
7658                                        {
7659                                        setState(931);
7660                                        match(LEADING_ASTERISK);
7661                                        }
7662                                        break;
7663                                case WS:
7664                                        {
7665                                        setState(932);
7666                                        match(WS);
7667                                        }
7668                                        break;
7669                                default:
7670                                        throw new NoViableAltException(this);
7671                                }
7672                                }
7673                                setState(937);
7674                                _errHandler.sync(this);
7675                                _la = _input.LA(1);
7676                        }
7677                        setState(938);
7678                        match(CLOSE);
7679                        }
7680                }
7681                catch (RecognitionException re) {
7682                        _localctx.exception = re;
7683                        _errHandler.reportError(this, re);
7684                        _errHandler.recover(this, re);
7685                }
7686                finally {
7687                        exitRule();
7688                }
7689                return _localctx;
7690        }
7691
7692        public static class HeadTagCloseContext extends ParserRuleContext {
7693                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7694                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7695                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7696                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7697                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7698                public TerminalNode NEWLINE(int i) {
7699                        return getToken(JavadocParser.NEWLINE, i);
7700                }
7701                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7702                public TerminalNode LEADING_ASTERISK(int i) {
7703                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7704                }
7705                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7706                public TerminalNode WS(int i) {
7707                        return getToken(JavadocParser.WS, i);
7708                }
7709                public HeadTagCloseContext(ParserRuleContext parent, int invokingState) {
7710                        super(parent, invokingState);
7711                }
7712                @Override public int getRuleIndex() { return RULE_headTagClose; }
7713                @Override
7714                public void enterRule(ParseTreeListener listener) {
7715                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this);
7716                }
7717                @Override
7718                public void exitRule(ParseTreeListener listener) {
7719                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this);
7720                }
7721                @Override
7722                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7723                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this);
7724                        else return visitor.visitChildren(this);
7725                }
7726        }
7727
7728        public final HeadTagCloseContext headTagClose() throws RecognitionException {
7729                HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState());
7730                enterRule(_localctx, 68, RULE_headTagClose);
7731                int _la;
7732                try {
7733                        enterOuterAlt(_localctx, 1);
7734                        {
7735                        setState(940);
7736                        match(OPEN);
7737                        setState(941);
7738                        match(SLASH);
7739                        setState(942);
7740                        match(HEAD_HTML_TAG_NAME);
7741                        setState(946);
7742                        _errHandler.sync(this);
7743                        _la = _input.LA(1);
7744                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7745                                {
7746                                {
7747                                setState(943);
7748                                _la = _input.LA(1);
7749                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7750                                _errHandler.recoverInline(this);
7751                                } else {
7752                                        consume();
7753                                }
7754                                }
7755                                }
7756                                setState(948);
7757                                _errHandler.sync(this);
7758                                _la = _input.LA(1);
7759                        }
7760                        setState(949);
7761                        match(CLOSE);
7762                        }
7763                }
7764                catch (RecognitionException re) {
7765                        _localctx.exception = re;
7766                        _errHandler.reportError(this, re);
7767                        _errHandler.recover(this, re);
7768                }
7769                finally {
7770                        exitRule();
7771                }
7772                return _localctx;
7773        }
7774
7775        public static class HeadContext extends ParserRuleContext {
7776                public HeadTagOpenContext headTagOpen() {
7777                        return getRuleContext(HeadTagOpenContext.class,0);
7778                }
7779                public HeadTagCloseContext headTagClose() {
7780                        return getRuleContext(HeadTagCloseContext.class,0);
7781                }
7782                public List<HtmlTagContext> htmlTag() {
7783                        return getRuleContexts(HtmlTagContext.class);
7784                }
7785                public HtmlTagContext htmlTag(int i) {
7786                        return getRuleContext(HtmlTagContext.class,i);
7787                }
7788                public List<SingletonTagContext> singletonTag() {
7789                        return getRuleContexts(SingletonTagContext.class);
7790                }
7791                public SingletonTagContext singletonTag(int i) {
7792                        return getRuleContext(SingletonTagContext.class,i);
7793                }
7794                public List<ParagraphContext> paragraph() {
7795                        return getRuleContexts(ParagraphContext.class);
7796                }
7797                public ParagraphContext paragraph(int i) {
7798                        return getRuleContext(ParagraphContext.class,i);
7799                }
7800                public List<LiContext> li() {
7801                        return getRuleContexts(LiContext.class);
7802                }
7803                public LiContext li(int i) {
7804                        return getRuleContext(LiContext.class,i);
7805                }
7806                public List<TrContext> tr() {
7807                        return getRuleContexts(TrContext.class);
7808                }
7809                public TrContext tr(int i) {
7810                        return getRuleContext(TrContext.class,i);
7811                }
7812                public List<TdContext> td() {
7813                        return getRuleContexts(TdContext.class);
7814                }
7815                public TdContext td(int i) {
7816                        return getRuleContext(TdContext.class,i);
7817                }
7818                public List<ThContext> th() {
7819                        return getRuleContexts(ThContext.class);
7820                }
7821                public ThContext th(int i) {
7822                        return getRuleContext(ThContext.class,i);
7823                }
7824                public List<BodyContext> body() {
7825                        return getRuleContexts(BodyContext.class);
7826                }
7827                public BodyContext body(int i) {
7828                        return getRuleContext(BodyContext.class,i);
7829                }
7830                public List<ColgroupContext> colgroup() {
7831                        return getRuleContexts(ColgroupContext.class);
7832                }
7833                public ColgroupContext colgroup(int i) {
7834                        return getRuleContext(ColgroupContext.class,i);
7835                }
7836                public List<DdContext> dd() {
7837                        return getRuleContexts(DdContext.class);
7838                }
7839                public DdContext dd(int i) {
7840                        return getRuleContext(DdContext.class,i);
7841                }
7842                public List<DtContext> dt() {
7843                        return getRuleContexts(DtContext.class);
7844                }
7845                public DtContext dt(int i) {
7846                        return getRuleContext(DtContext.class,i);
7847                }
7848                public List<HtmlContext> html() {
7849                        return getRuleContexts(HtmlContext.class);
7850                }
7851                public HtmlContext html(int i) {
7852                        return getRuleContext(HtmlContext.class,i);
7853                }
7854                public List<OptionContext> option() {
7855                        return getRuleContexts(OptionContext.class);
7856                }
7857                public OptionContext option(int i) {
7858                        return getRuleContext(OptionContext.class,i);
7859                }
7860                public List<TbodyContext> tbody() {
7861                        return getRuleContexts(TbodyContext.class);
7862                }
7863                public TbodyContext tbody(int i) {
7864                        return getRuleContext(TbodyContext.class,i);
7865                }
7866                public List<TheadContext> thead() {
7867                        return getRuleContexts(TheadContext.class);
7868                }
7869                public TheadContext thead(int i) {
7870                        return getRuleContext(TheadContext.class,i);
7871                }
7872                public List<TfootContext> tfoot() {
7873                        return getRuleContexts(TfootContext.class);
7874                }
7875                public TfootContext tfoot(int i) {
7876                        return getRuleContext(TfootContext.class,i);
7877                }
7878                public List<PTagOpenContext> pTagOpen() {
7879                        return getRuleContexts(PTagOpenContext.class);
7880                }
7881                public PTagOpenContext pTagOpen(int i) {
7882                        return getRuleContext(PTagOpenContext.class,i);
7883                }
7884                public List<LiTagOpenContext> liTagOpen() {
7885                        return getRuleContexts(LiTagOpenContext.class);
7886                }
7887                public LiTagOpenContext liTagOpen(int i) {
7888                        return getRuleContext(LiTagOpenContext.class,i);
7889                }
7890                public List<TrTagOpenContext> trTagOpen() {
7891                        return getRuleContexts(TrTagOpenContext.class);
7892                }
7893                public TrTagOpenContext trTagOpen(int i) {
7894                        return getRuleContext(TrTagOpenContext.class,i);
7895                }
7896                public List<TdTagOpenContext> tdTagOpen() {
7897                        return getRuleContexts(TdTagOpenContext.class);
7898                }
7899                public TdTagOpenContext tdTagOpen(int i) {
7900                        return getRuleContext(TdTagOpenContext.class,i);
7901                }
7902                public List<ThTagOpenContext> thTagOpen() {
7903                        return getRuleContexts(ThTagOpenContext.class);
7904                }
7905                public ThTagOpenContext thTagOpen(int i) {
7906                        return getRuleContext(ThTagOpenContext.class,i);
7907                }
7908                public List<BodyTagOpenContext> bodyTagOpen() {
7909                        return getRuleContexts(BodyTagOpenContext.class);
7910                }
7911                public BodyTagOpenContext bodyTagOpen(int i) {
7912                        return getRuleContext(BodyTagOpenContext.class,i);
7913                }
7914                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7915                        return getRuleContexts(ColgroupTagOpenContext.class);
7916                }
7917                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7918                        return getRuleContext(ColgroupTagOpenContext.class,i);
7919                }
7920                public List<DdTagOpenContext> ddTagOpen() {
7921                        return getRuleContexts(DdTagOpenContext.class);
7922                }
7923                public DdTagOpenContext ddTagOpen(int i) {
7924                        return getRuleContext(DdTagOpenContext.class,i);
7925                }
7926                public List<DtTagOpenContext> dtTagOpen() {
7927                        return getRuleContexts(DtTagOpenContext.class);
7928                }
7929                public DtTagOpenContext dtTagOpen(int i) {
7930                        return getRuleContext(DtTagOpenContext.class,i);
7931                }
7932                public List<HtmlTagOpenContext> htmlTagOpen() {
7933                        return getRuleContexts(HtmlTagOpenContext.class);
7934                }
7935                public HtmlTagOpenContext htmlTagOpen(int i) {
7936                        return getRuleContext(HtmlTagOpenContext.class,i);
7937                }
7938                public List<OptionTagOpenContext> optionTagOpen() {
7939                        return getRuleContexts(OptionTagOpenContext.class);
7940                }
7941                public OptionTagOpenContext optionTagOpen(int i) {
7942                        return getRuleContext(OptionTagOpenContext.class,i);
7943                }
7944                public List<TbodyTagOpenContext> tbodyTagOpen() {
7945                        return getRuleContexts(TbodyTagOpenContext.class);
7946                }
7947                public TbodyTagOpenContext tbodyTagOpen(int i) {
7948                        return getRuleContext(TbodyTagOpenContext.class,i);
7949                }
7950                public List<TheadTagOpenContext> theadTagOpen() {
7951                        return getRuleContexts(TheadTagOpenContext.class);
7952                }
7953                public TheadTagOpenContext theadTagOpen(int i) {
7954                        return getRuleContext(TheadTagOpenContext.class,i);
7955                }
7956                public List<TfootTagOpenContext> tfootTagOpen() {
7957                        return getRuleContexts(TfootTagOpenContext.class);
7958                }
7959                public TfootTagOpenContext tfootTagOpen(int i) {
7960                        return getRuleContext(TfootTagOpenContext.class,i);
7961                }
7962                public List<HtmlCommentContext> htmlComment() {
7963                        return getRuleContexts(HtmlCommentContext.class);
7964                }
7965                public HtmlCommentContext htmlComment(int i) {
7966                        return getRuleContext(HtmlCommentContext.class,i);
7967                }
7968                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7969                public TerminalNode CDATA(int i) {
7970                        return getToken(JavadocParser.CDATA, i);
7971                }
7972                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7973                public TerminalNode NEWLINE(int i) {
7974                        return getToken(JavadocParser.NEWLINE, i);
7975                }
7976                public List<TextContext> text() {
7977                        return getRuleContexts(TextContext.class);
7978                }
7979                public TextContext text(int i) {
7980                        return getRuleContext(TextContext.class,i);
7981                }
7982                public List<JavadocInlineTagContext> javadocInlineTag() {
7983                        return getRuleContexts(JavadocInlineTagContext.class);
7984                }
7985                public JavadocInlineTagContext javadocInlineTag(int i) {
7986                        return getRuleContext(JavadocInlineTagContext.class,i);
7987                }
7988                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7989                public TerminalNode LEADING_ASTERISK(int i) {
7990                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7991                }
7992                public HeadContext(ParserRuleContext parent, int invokingState) {
7993                        super(parent, invokingState);
7994                }
7995                @Override public int getRuleIndex() { return RULE_head; }
7996                @Override
7997                public void enterRule(ParseTreeListener listener) {
7998                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this);
7999                }
8000                @Override
8001                public void exitRule(ParseTreeListener listener) {
8002                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this);
8003                }
8004                @Override
8005                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8006                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this);
8007                        else return visitor.visitChildren(this);
8008                }
8009        }
8010
8011        public final HeadContext head() throws RecognitionException {
8012                HeadContext _localctx = new HeadContext(_ctx, getState());
8013                enterRule(_localctx, 70, RULE_head);
8014                try {
8015                        int _alt;
8016                        enterOuterAlt(_localctx, 1);
8017                        {
8018                        setState(951);
8019                        headTagOpen();
8020                        setState(991);
8021                        _errHandler.sync(this);
8022                        _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8023                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8024                                if ( _alt==1 ) {
8025                                        {
8026                                        setState(989);
8027                                        switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
8028                                        case 1:
8029                                                {
8030                                                setState(952);
8031                                                htmlTag();
8032                                                }
8033                                                break;
8034                                        case 2:
8035                                                {
8036                                                setState(953);
8037                                                singletonTag();
8038                                                }
8039                                                break;
8040                                        case 3:
8041                                                {
8042                                                setState(954);
8043                                                paragraph();
8044                                                }
8045                                                break;
8046                                        case 4:
8047                                                {
8048                                                setState(955);
8049                                                li();
8050                                                }
8051                                                break;
8052                                        case 5:
8053                                                {
8054                                                setState(956);
8055                                                tr();
8056                                                }
8057                                                break;
8058                                        case 6:
8059                                                {
8060                                                setState(957);
8061                                                td();
8062                                                }
8063                                                break;
8064                                        case 7:
8065                                                {
8066                                                setState(958);
8067                                                th();
8068                                                }
8069                                                break;
8070                                        case 8:
8071                                                {
8072                                                setState(959);
8073                                                body();
8074                                                }
8075                                                break;
8076                                        case 9:
8077                                                {
8078                                                setState(960);
8079                                                colgroup();
8080                                                }
8081                                                break;
8082                                        case 10:
8083                                                {
8084                                                setState(961);
8085                                                dd();
8086                                                }
8087                                                break;
8088                                        case 11:
8089                                                {
8090                                                setState(962);
8091                                                dt();
8092                                                }
8093                                                break;
8094                                        case 12:
8095                                                {
8096                                                setState(963);
8097                                                html();
8098                                                }
8099                                                break;
8100                                        case 13:
8101                                                {
8102                                                setState(964);
8103                                                option();
8104                                                }
8105                                                break;
8106                                        case 14:
8107                                                {
8108                                                setState(965);
8109                                                tbody();
8110                                                }
8111                                                break;
8112                                        case 15:
8113                                                {
8114                                                setState(966);
8115                                                thead();
8116                                                }
8117                                                break;
8118                                        case 16:
8119                                                {
8120                                                setState(967);
8121                                                tfoot();
8122                                                }
8123                                                break;
8124                                        case 17:
8125                                                {
8126                                                setState(968);
8127                                                pTagOpen();
8128                                                }
8129                                                break;
8130                                        case 18:
8131                                                {
8132                                                setState(969);
8133                                                liTagOpen();
8134                                                }
8135                                                break;
8136                                        case 19:
8137                                                {
8138                                                setState(970);
8139                                                trTagOpen();
8140                                                }
8141                                                break;
8142                                        case 20:
8143                                                {
8144                                                setState(971);
8145                                                tdTagOpen();
8146                                                }
8147                                                break;
8148                                        case 21:
8149                                                {
8150                                                setState(972);
8151                                                thTagOpen();
8152                                                }
8153                                                break;
8154                                        case 22:
8155                                                {
8156                                                setState(973);
8157                                                bodyTagOpen();
8158                                                }
8159                                                break;
8160                                        case 23:
8161                                                {
8162                                                setState(974);
8163                                                colgroupTagOpen();
8164                                                }
8165                                                break;
8166                                        case 24:
8167                                                {
8168                                                setState(975);
8169                                                ddTagOpen();
8170                                                }
8171                                                break;
8172                                        case 25:
8173                                                {
8174                                                setState(976);
8175                                                dtTagOpen();
8176                                                }
8177                                                break;
8178                                        case 26:
8179                                                {
8180                                                setState(977);
8181                                                htmlTagOpen();
8182                                                }
8183                                                break;
8184                                        case 27:
8185                                                {
8186                                                setState(978);
8187                                                optionTagOpen();
8188                                                }
8189                                                break;
8190                                        case 28:
8191                                                {
8192                                                setState(979);
8193                                                tbodyTagOpen();
8194                                                }
8195                                                break;
8196                                        case 29:
8197                                                {
8198                                                setState(980);
8199                                                theadTagOpen();
8200                                                }
8201                                                break;
8202                                        case 30:
8203                                                {
8204                                                setState(981);
8205                                                tfootTagOpen();
8206                                                }
8207                                                break;
8208                                        case 31:
8209                                                {
8210                                                {
8211                                                setState(982);
8212                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8213                                                setState(983);
8214                                                match(LEADING_ASTERISK);
8215                                                }
8216                                                }
8217                                                break;
8218                                        case 32:
8219                                                {
8220                                                setState(984);
8221                                                htmlComment();
8222                                                }
8223                                                break;
8224                                        case 33:
8225                                                {
8226                                                setState(985);
8227                                                match(CDATA);
8228                                                }
8229                                                break;
8230                                        case 34:
8231                                                {
8232                                                setState(986);
8233                                                match(NEWLINE);
8234                                                }
8235                                                break;
8236                                        case 35:
8237                                                {
8238                                                setState(987);
8239                                                text();
8240                                                }
8241                                                break;
8242                                        case 36:
8243                                                {
8244                                                setState(988);
8245                                                javadocInlineTag();
8246                                                }
8247                                                break;
8248                                        }
8249                                        } 
8250                                }
8251                                setState(993);
8252                                _errHandler.sync(this);
8253                                _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8254                        }
8255                        setState(994);
8256                        headTagClose();
8257                        }
8258                }
8259                catch (RecognitionException re) {
8260                        _localctx.exception = re;
8261                        _errHandler.reportError(this, re);
8262                        _errHandler.recover(this, re);
8263                }
8264                finally {
8265                        exitRule();
8266                }
8267                return _localctx;
8268        }
8269
8270        public static class HtmlTagOpenContext extends ParserRuleContext {
8271                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8272                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8273                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8274                public List<AttributeContext> attribute() {
8275                        return getRuleContexts(AttributeContext.class);
8276                }
8277                public AttributeContext attribute(int i) {
8278                        return getRuleContext(AttributeContext.class,i);
8279                }
8280                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8281                public TerminalNode NEWLINE(int i) {
8282                        return getToken(JavadocParser.NEWLINE, i);
8283                }
8284                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8285                public TerminalNode LEADING_ASTERISK(int i) {
8286                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8287                }
8288                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8289                public TerminalNode WS(int i) {
8290                        return getToken(JavadocParser.WS, i);
8291                }
8292                public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) {
8293                        super(parent, invokingState);
8294                }
8295                @Override public int getRuleIndex() { return RULE_htmlTagOpen; }
8296                @Override
8297                public void enterRule(ParseTreeListener listener) {
8298                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this);
8299                }
8300                @Override
8301                public void exitRule(ParseTreeListener listener) {
8302                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this);
8303                }
8304                @Override
8305                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8306                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this);
8307                        else return visitor.visitChildren(this);
8308                }
8309        }
8310
8311        public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException {
8312                HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState());
8313                enterRule(_localctx, 72, RULE_htmlTagOpen);
8314                int _la;
8315                try {
8316                        enterOuterAlt(_localctx, 1);
8317                        {
8318                        setState(996);
8319                        match(OPEN);
8320                        setState(997);
8321                        match(HTML_HTML_TAG_NAME);
8322                        setState(1004);
8323                        _errHandler.sync(this);
8324                        _la = _input.LA(1);
8325                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8326                                {
8327                                setState(1002);
8328                                switch (_input.LA(1)) {
8329                                case HTML_TAG_NAME:
8330                                        {
8331                                        setState(998);
8332                                        attribute();
8333                                        }
8334                                        break;
8335                                case NEWLINE:
8336                                        {
8337                                        setState(999);
8338                                        match(NEWLINE);
8339                                        }
8340                                        break;
8341                                case LEADING_ASTERISK:
8342                                        {
8343                                        setState(1000);
8344                                        match(LEADING_ASTERISK);
8345                                        }
8346                                        break;
8347                                case WS:
8348                                        {
8349                                        setState(1001);
8350                                        match(WS);
8351                                        }
8352                                        break;
8353                                default:
8354                                        throw new NoViableAltException(this);
8355                                }
8356                                }
8357                                setState(1006);
8358                                _errHandler.sync(this);
8359                                _la = _input.LA(1);
8360                        }
8361                        setState(1007);
8362                        match(CLOSE);
8363                        }
8364                }
8365                catch (RecognitionException re) {
8366                        _localctx.exception = re;
8367                        _errHandler.reportError(this, re);
8368                        _errHandler.recover(this, re);
8369                }
8370                finally {
8371                        exitRule();
8372                }
8373                return _localctx;
8374        }
8375
8376        public static class HtmlTagCloseContext extends ParserRuleContext {
8377                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8378                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8379                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8380                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8381                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8382                public TerminalNode NEWLINE(int i) {
8383                        return getToken(JavadocParser.NEWLINE, i);
8384                }
8385                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8386                public TerminalNode LEADING_ASTERISK(int i) {
8387                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8388                }
8389                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8390                public TerminalNode WS(int i) {
8391                        return getToken(JavadocParser.WS, i);
8392                }
8393                public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) {
8394                        super(parent, invokingState);
8395                }
8396                @Override public int getRuleIndex() { return RULE_htmlTagClose; }
8397                @Override
8398                public void enterRule(ParseTreeListener listener) {
8399                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this);
8400                }
8401                @Override
8402                public void exitRule(ParseTreeListener listener) {
8403                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this);
8404                }
8405                @Override
8406                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8407                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this);
8408                        else return visitor.visitChildren(this);
8409                }
8410        }
8411
8412        public final HtmlTagCloseContext htmlTagClose() throws RecognitionException {
8413                HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState());
8414                enterRule(_localctx, 74, RULE_htmlTagClose);
8415                int _la;
8416                try {
8417                        enterOuterAlt(_localctx, 1);
8418                        {
8419                        setState(1009);
8420                        match(OPEN);
8421                        setState(1010);
8422                        match(SLASH);
8423                        setState(1011);
8424                        match(HTML_HTML_TAG_NAME);
8425                        setState(1015);
8426                        _errHandler.sync(this);
8427                        _la = _input.LA(1);
8428                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8429                                {
8430                                {
8431                                setState(1012);
8432                                _la = _input.LA(1);
8433                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8434                                _errHandler.recoverInline(this);
8435                                } else {
8436                                        consume();
8437                                }
8438                                }
8439                                }
8440                                setState(1017);
8441                                _errHandler.sync(this);
8442                                _la = _input.LA(1);
8443                        }
8444                        setState(1018);
8445                        match(CLOSE);
8446                        }
8447                }
8448                catch (RecognitionException re) {
8449                        _localctx.exception = re;
8450                        _errHandler.reportError(this, re);
8451                        _errHandler.recover(this, re);
8452                }
8453                finally {
8454                        exitRule();
8455                }
8456                return _localctx;
8457        }
8458
8459        public static class HtmlContext extends ParserRuleContext {
8460                public HtmlTagOpenContext htmlTagOpen() {
8461                        return getRuleContext(HtmlTagOpenContext.class,0);
8462                }
8463                public HtmlTagCloseContext htmlTagClose() {
8464                        return getRuleContext(HtmlTagCloseContext.class,0);
8465                }
8466                public List<HtmlTagContext> htmlTag() {
8467                        return getRuleContexts(HtmlTagContext.class);
8468                }
8469                public HtmlTagContext htmlTag(int i) {
8470                        return getRuleContext(HtmlTagContext.class,i);
8471                }
8472                public List<SingletonTagContext> singletonTag() {
8473                        return getRuleContexts(SingletonTagContext.class);
8474                }
8475                public SingletonTagContext singletonTag(int i) {
8476                        return getRuleContext(SingletonTagContext.class,i);
8477                }
8478                public List<ParagraphContext> paragraph() {
8479                        return getRuleContexts(ParagraphContext.class);
8480                }
8481                public ParagraphContext paragraph(int i) {
8482                        return getRuleContext(ParagraphContext.class,i);
8483                }
8484                public List<LiContext> li() {
8485                        return getRuleContexts(LiContext.class);
8486                }
8487                public LiContext li(int i) {
8488                        return getRuleContext(LiContext.class,i);
8489                }
8490                public List<TrContext> tr() {
8491                        return getRuleContexts(TrContext.class);
8492                }
8493                public TrContext tr(int i) {
8494                        return getRuleContext(TrContext.class,i);
8495                }
8496                public List<TdContext> td() {
8497                        return getRuleContexts(TdContext.class);
8498                }
8499                public TdContext td(int i) {
8500                        return getRuleContext(TdContext.class,i);
8501                }
8502                public List<ThContext> th() {
8503                        return getRuleContexts(ThContext.class);
8504                }
8505                public ThContext th(int i) {
8506                        return getRuleContext(ThContext.class,i);
8507                }
8508                public List<BodyContext> body() {
8509                        return getRuleContexts(BodyContext.class);
8510                }
8511                public BodyContext body(int i) {
8512                        return getRuleContext(BodyContext.class,i);
8513                }
8514                public List<ColgroupContext> colgroup() {
8515                        return getRuleContexts(ColgroupContext.class);
8516                }
8517                public ColgroupContext colgroup(int i) {
8518                        return getRuleContext(ColgroupContext.class,i);
8519                }
8520                public List<DdContext> dd() {
8521                        return getRuleContexts(DdContext.class);
8522                }
8523                public DdContext dd(int i) {
8524                        return getRuleContext(DdContext.class,i);
8525                }
8526                public List<DtContext> dt() {
8527                        return getRuleContexts(DtContext.class);
8528                }
8529                public DtContext dt(int i) {
8530                        return getRuleContext(DtContext.class,i);
8531                }
8532                public List<HeadContext> head() {
8533                        return getRuleContexts(HeadContext.class);
8534                }
8535                public HeadContext head(int i) {
8536                        return getRuleContext(HeadContext.class,i);
8537                }
8538                public List<OptionContext> option() {
8539                        return getRuleContexts(OptionContext.class);
8540                }
8541                public OptionContext option(int i) {
8542                        return getRuleContext(OptionContext.class,i);
8543                }
8544                public List<TbodyContext> tbody() {
8545                        return getRuleContexts(TbodyContext.class);
8546                }
8547                public TbodyContext tbody(int i) {
8548                        return getRuleContext(TbodyContext.class,i);
8549                }
8550                public List<TheadContext> thead() {
8551                        return getRuleContexts(TheadContext.class);
8552                }
8553                public TheadContext thead(int i) {
8554                        return getRuleContext(TheadContext.class,i);
8555                }
8556                public List<TfootContext> tfoot() {
8557                        return getRuleContexts(TfootContext.class);
8558                }
8559                public TfootContext tfoot(int i) {
8560                        return getRuleContext(TfootContext.class,i);
8561                }
8562                public List<PTagOpenContext> pTagOpen() {
8563                        return getRuleContexts(PTagOpenContext.class);
8564                }
8565                public PTagOpenContext pTagOpen(int i) {
8566                        return getRuleContext(PTagOpenContext.class,i);
8567                }
8568                public List<LiTagOpenContext> liTagOpen() {
8569                        return getRuleContexts(LiTagOpenContext.class);
8570                }
8571                public LiTagOpenContext liTagOpen(int i) {
8572                        return getRuleContext(LiTagOpenContext.class,i);
8573                }
8574                public List<TrTagOpenContext> trTagOpen() {
8575                        return getRuleContexts(TrTagOpenContext.class);
8576                }
8577                public TrTagOpenContext trTagOpen(int i) {
8578                        return getRuleContext(TrTagOpenContext.class,i);
8579                }
8580                public List<TdTagOpenContext> tdTagOpen() {
8581                        return getRuleContexts(TdTagOpenContext.class);
8582                }
8583                public TdTagOpenContext tdTagOpen(int i) {
8584                        return getRuleContext(TdTagOpenContext.class,i);
8585                }
8586                public List<ThTagOpenContext> thTagOpen() {
8587                        return getRuleContexts(ThTagOpenContext.class);
8588                }
8589                public ThTagOpenContext thTagOpen(int i) {
8590                        return getRuleContext(ThTagOpenContext.class,i);
8591                }
8592                public List<BodyTagOpenContext> bodyTagOpen() {
8593                        return getRuleContexts(BodyTagOpenContext.class);
8594                }
8595                public BodyTagOpenContext bodyTagOpen(int i) {
8596                        return getRuleContext(BodyTagOpenContext.class,i);
8597                }
8598                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8599                        return getRuleContexts(ColgroupTagOpenContext.class);
8600                }
8601                public ColgroupTagOpenContext colgroupTagOpen(int i) {
8602                        return getRuleContext(ColgroupTagOpenContext.class,i);
8603                }
8604                public List<DdTagOpenContext> ddTagOpen() {
8605                        return getRuleContexts(DdTagOpenContext.class);
8606                }
8607                public DdTagOpenContext ddTagOpen(int i) {
8608                        return getRuleContext(DdTagOpenContext.class,i);
8609                }
8610                public List<DtTagOpenContext> dtTagOpen() {
8611                        return getRuleContexts(DtTagOpenContext.class);
8612                }
8613                public DtTagOpenContext dtTagOpen(int i) {
8614                        return getRuleContext(DtTagOpenContext.class,i);
8615                }
8616                public List<HeadTagOpenContext> headTagOpen() {
8617                        return getRuleContexts(HeadTagOpenContext.class);
8618                }
8619                public HeadTagOpenContext headTagOpen(int i) {
8620                        return getRuleContext(HeadTagOpenContext.class,i);
8621                }
8622                public List<OptionTagOpenContext> optionTagOpen() {
8623                        return getRuleContexts(OptionTagOpenContext.class);
8624                }
8625                public OptionTagOpenContext optionTagOpen(int i) {
8626                        return getRuleContext(OptionTagOpenContext.class,i);
8627                }
8628                public List<TbodyTagOpenContext> tbodyTagOpen() {
8629                        return getRuleContexts(TbodyTagOpenContext.class);
8630                }
8631                public TbodyTagOpenContext tbodyTagOpen(int i) {
8632                        return getRuleContext(TbodyTagOpenContext.class,i);
8633                }
8634                public List<TheadTagOpenContext> theadTagOpen() {
8635                        return getRuleContexts(TheadTagOpenContext.class);
8636                }
8637                public TheadTagOpenContext theadTagOpen(int i) {
8638                        return getRuleContext(TheadTagOpenContext.class,i);
8639                }
8640                public List<TfootTagOpenContext> tfootTagOpen() {
8641                        return getRuleContexts(TfootTagOpenContext.class);
8642                }
8643                public TfootTagOpenContext tfootTagOpen(int i) {
8644                        return getRuleContext(TfootTagOpenContext.class,i);
8645                }
8646                public List<HtmlCommentContext> htmlComment() {
8647                        return getRuleContexts(HtmlCommentContext.class);
8648                }
8649                public HtmlCommentContext htmlComment(int i) {
8650                        return getRuleContext(HtmlCommentContext.class,i);
8651                }
8652                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8653                public TerminalNode CDATA(int i) {
8654                        return getToken(JavadocParser.CDATA, i);
8655                }
8656                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8657                public TerminalNode NEWLINE(int i) {
8658                        return getToken(JavadocParser.NEWLINE, i);
8659                }
8660                public List<TextContext> text() {
8661                        return getRuleContexts(TextContext.class);
8662                }
8663                public TextContext text(int i) {
8664                        return getRuleContext(TextContext.class,i);
8665                }
8666                public List<JavadocInlineTagContext> javadocInlineTag() {
8667                        return getRuleContexts(JavadocInlineTagContext.class);
8668                }
8669                public JavadocInlineTagContext javadocInlineTag(int i) {
8670                        return getRuleContext(JavadocInlineTagContext.class,i);
8671                }
8672                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8673                public TerminalNode LEADING_ASTERISK(int i) {
8674                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8675                }
8676                public HtmlContext(ParserRuleContext parent, int invokingState) {
8677                        super(parent, invokingState);
8678                }
8679                @Override public int getRuleIndex() { return RULE_html; }
8680                @Override
8681                public void enterRule(ParseTreeListener listener) {
8682                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this);
8683                }
8684                @Override
8685                public void exitRule(ParseTreeListener listener) {
8686                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this);
8687                }
8688                @Override
8689                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8690                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this);
8691                        else return visitor.visitChildren(this);
8692                }
8693        }
8694
8695        public final HtmlContext html() throws RecognitionException {
8696                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8697                enterRule(_localctx, 76, RULE_html);
8698                try {
8699                        int _alt;
8700                        enterOuterAlt(_localctx, 1);
8701                        {
8702                        setState(1020);
8703                        htmlTagOpen();
8704                        setState(1060);
8705                        _errHandler.sync(this);
8706                        _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8707                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8708                                if ( _alt==1 ) {
8709                                        {
8710                                        setState(1058);
8711                                        switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
8712                                        case 1:
8713                                                {
8714                                                setState(1021);
8715                                                htmlTag();
8716                                                }
8717                                                break;
8718                                        case 2:
8719                                                {
8720                                                setState(1022);
8721                                                singletonTag();
8722                                                }
8723                                                break;
8724                                        case 3:
8725                                                {
8726                                                setState(1023);
8727                                                paragraph();
8728                                                }
8729                                                break;
8730                                        case 4:
8731                                                {
8732                                                setState(1024);
8733                                                li();
8734                                                }
8735                                                break;
8736                                        case 5:
8737                                                {
8738                                                setState(1025);
8739                                                tr();
8740                                                }
8741                                                break;
8742                                        case 6:
8743                                                {
8744                                                setState(1026);
8745                                                td();
8746                                                }
8747                                                break;
8748                                        case 7:
8749                                                {
8750                                                setState(1027);
8751                                                th();
8752                                                }
8753                                                break;
8754                                        case 8:
8755                                                {
8756                                                setState(1028);
8757                                                body();
8758                                                }
8759                                                break;
8760                                        case 9:
8761                                                {
8762                                                setState(1029);
8763                                                colgroup();
8764                                                }
8765                                                break;
8766                                        case 10:
8767                                                {
8768                                                setState(1030);
8769                                                dd();
8770                                                }
8771                                                break;
8772                                        case 11:
8773                                                {
8774                                                setState(1031);
8775                                                dt();
8776                                                }
8777                                                break;
8778                                        case 12:
8779                                                {
8780                                                setState(1032);
8781                                                head();
8782                                                }
8783                                                break;
8784                                        case 13:
8785                                                {
8786                                                setState(1033);
8787                                                option();
8788                                                }
8789                                                break;
8790                                        case 14:
8791                                                {
8792                                                setState(1034);
8793                                                tbody();
8794                                                }
8795                                                break;
8796                                        case 15:
8797                                                {
8798                                                setState(1035);
8799                                                thead();
8800                                                }
8801                                                break;
8802                                        case 16:
8803                                                {
8804                                                setState(1036);
8805                                                tfoot();
8806                                                }
8807                                                break;
8808                                        case 17:
8809                                                {
8810                                                setState(1037);
8811                                                pTagOpen();
8812                                                }
8813                                                break;
8814                                        case 18:
8815                                                {
8816                                                setState(1038);
8817                                                liTagOpen();
8818                                                }
8819                                                break;
8820                                        case 19:
8821                                                {
8822                                                setState(1039);
8823                                                trTagOpen();
8824                                                }
8825                                                break;
8826                                        case 20:
8827                                                {
8828                                                setState(1040);
8829                                                tdTagOpen();
8830                                                }
8831                                                break;
8832                                        case 21:
8833                                                {
8834                                                setState(1041);
8835                                                thTagOpen();
8836                                                }
8837                                                break;
8838                                        case 22:
8839                                                {
8840                                                setState(1042);
8841                                                bodyTagOpen();
8842                                                }
8843                                                break;
8844                                        case 23:
8845                                                {
8846                                                setState(1043);
8847                                                colgroupTagOpen();
8848                                                }
8849                                                break;
8850                                        case 24:
8851                                                {
8852                                                setState(1044);
8853                                                ddTagOpen();
8854                                                }
8855                                                break;
8856                                        case 25:
8857                                                {
8858                                                setState(1045);
8859                                                dtTagOpen();
8860                                                }
8861                                                break;
8862                                        case 26:
8863                                                {
8864                                                setState(1046);
8865                                                headTagOpen();
8866                                                }
8867                                                break;
8868                                        case 27:
8869                                                {
8870                                                setState(1047);
8871                                                optionTagOpen();
8872                                                }
8873                                                break;
8874                                        case 28:
8875                                                {
8876                                                setState(1048);
8877                                                tbodyTagOpen();
8878                                                }
8879                                                break;
8880                                        case 29:
8881                                                {
8882                                                setState(1049);
8883                                                theadTagOpen();
8884                                                }
8885                                                break;
8886                                        case 30:
8887                                                {
8888                                                setState(1050);
8889                                                tfootTagOpen();
8890                                                }
8891                                                break;
8892                                        case 31:
8893                                                {
8894                                                {
8895                                                setState(1051);
8896                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8897                                                setState(1052);
8898                                                match(LEADING_ASTERISK);
8899                                                }
8900                                                }
8901                                                break;
8902                                        case 32:
8903                                                {
8904                                                setState(1053);
8905                                                htmlComment();
8906                                                }
8907                                                break;
8908                                        case 33:
8909                                                {
8910                                                setState(1054);
8911                                                match(CDATA);
8912                                                }
8913                                                break;
8914                                        case 34:
8915                                                {
8916                                                setState(1055);
8917                                                match(NEWLINE);
8918                                                }
8919                                                break;
8920                                        case 35:
8921                                                {
8922                                                setState(1056);
8923                                                text();
8924                                                }
8925                                                break;
8926                                        case 36:
8927                                                {
8928                                                setState(1057);
8929                                                javadocInlineTag();
8930                                                }
8931                                                break;
8932                                        }
8933                                        } 
8934                                }
8935                                setState(1062);
8936                                _errHandler.sync(this);
8937                                _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8938                        }
8939                        setState(1063);
8940                        htmlTagClose();
8941                        }
8942                }
8943                catch (RecognitionException re) {
8944                        _localctx.exception = re;
8945                        _errHandler.reportError(this, re);
8946                        _errHandler.recover(this, re);
8947                }
8948                finally {
8949                        exitRule();
8950                }
8951                return _localctx;
8952        }
8953
8954        public static class OptionTagOpenContext extends ParserRuleContext {
8955                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8956                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8957                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8958                public List<AttributeContext> attribute() {
8959                        return getRuleContexts(AttributeContext.class);
8960                }
8961                public AttributeContext attribute(int i) {
8962                        return getRuleContext(AttributeContext.class,i);
8963                }
8964                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8965                public TerminalNode NEWLINE(int i) {
8966                        return getToken(JavadocParser.NEWLINE, i);
8967                }
8968                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8969                public TerminalNode LEADING_ASTERISK(int i) {
8970                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8971                }
8972                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8973                public TerminalNode WS(int i) {
8974                        return getToken(JavadocParser.WS, i);
8975                }
8976                public OptionTagOpenContext(ParserRuleContext parent, int invokingState) {
8977                        super(parent, invokingState);
8978                }
8979                @Override public int getRuleIndex() { return RULE_optionTagOpen; }
8980                @Override
8981                public void enterRule(ParseTreeListener listener) {
8982                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this);
8983                }
8984                @Override
8985                public void exitRule(ParseTreeListener listener) {
8986                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this);
8987                }
8988                @Override
8989                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8990                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this);
8991                        else return visitor.visitChildren(this);
8992                }
8993        }
8994
8995        public final OptionTagOpenContext optionTagOpen() throws RecognitionException {
8996                OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState());
8997                enterRule(_localctx, 78, RULE_optionTagOpen);
8998                int _la;
8999                try {
9000                        enterOuterAlt(_localctx, 1);
9001                        {
9002                        setState(1065);
9003                        match(OPEN);
9004                        setState(1066);
9005                        match(OPTION_HTML_TAG_NAME);
9006                        setState(1073);
9007                        _errHandler.sync(this);
9008                        _la = _input.LA(1);
9009                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9010                                {
9011                                setState(1071);
9012                                switch (_input.LA(1)) {
9013                                case HTML_TAG_NAME:
9014                                        {
9015                                        setState(1067);
9016                                        attribute();
9017                                        }
9018                                        break;
9019                                case NEWLINE:
9020                                        {
9021                                        setState(1068);
9022                                        match(NEWLINE);
9023                                        }
9024                                        break;
9025                                case LEADING_ASTERISK:
9026                                        {
9027                                        setState(1069);
9028                                        match(LEADING_ASTERISK);
9029                                        }
9030                                        break;
9031                                case WS:
9032                                        {
9033                                        setState(1070);
9034                                        match(WS);
9035                                        }
9036                                        break;
9037                                default:
9038                                        throw new NoViableAltException(this);
9039                                }
9040                                }
9041                                setState(1075);
9042                                _errHandler.sync(this);
9043                                _la = _input.LA(1);
9044                        }
9045                        setState(1076);
9046                        match(CLOSE);
9047                        }
9048                }
9049                catch (RecognitionException re) {
9050                        _localctx.exception = re;
9051                        _errHandler.reportError(this, re);
9052                        _errHandler.recover(this, re);
9053                }
9054                finally {
9055                        exitRule();
9056                }
9057                return _localctx;
9058        }
9059
9060        public static class OptionTagCloseContext extends ParserRuleContext {
9061                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9062                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9063                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9064                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9065                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9066                public TerminalNode NEWLINE(int i) {
9067                        return getToken(JavadocParser.NEWLINE, i);
9068                }
9069                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9070                public TerminalNode LEADING_ASTERISK(int i) {
9071                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9072                }
9073                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9074                public TerminalNode WS(int i) {
9075                        return getToken(JavadocParser.WS, i);
9076                }
9077                public OptionTagCloseContext(ParserRuleContext parent, int invokingState) {
9078                        super(parent, invokingState);
9079                }
9080                @Override public int getRuleIndex() { return RULE_optionTagClose; }
9081                @Override
9082                public void enterRule(ParseTreeListener listener) {
9083                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this);
9084                }
9085                @Override
9086                public void exitRule(ParseTreeListener listener) {
9087                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this);
9088                }
9089                @Override
9090                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9091                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this);
9092                        else return visitor.visitChildren(this);
9093                }
9094        }
9095
9096        public final OptionTagCloseContext optionTagClose() throws RecognitionException {
9097                OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState());
9098                enterRule(_localctx, 80, RULE_optionTagClose);
9099                int _la;
9100                try {
9101                        enterOuterAlt(_localctx, 1);
9102                        {
9103                        setState(1078);
9104                        match(OPEN);
9105                        setState(1079);
9106                        match(SLASH);
9107                        setState(1080);
9108                        match(OPTION_HTML_TAG_NAME);
9109                        setState(1084);
9110                        _errHandler.sync(this);
9111                        _la = _input.LA(1);
9112                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9113                                {
9114                                {
9115                                setState(1081);
9116                                _la = _input.LA(1);
9117                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9118                                _errHandler.recoverInline(this);
9119                                } else {
9120                                        consume();
9121                                }
9122                                }
9123                                }
9124                                setState(1086);
9125                                _errHandler.sync(this);
9126                                _la = _input.LA(1);
9127                        }
9128                        setState(1087);
9129                        match(CLOSE);
9130                        }
9131                }
9132                catch (RecognitionException re) {
9133                        _localctx.exception = re;
9134                        _errHandler.reportError(this, re);
9135                        _errHandler.recover(this, re);
9136                }
9137                finally {
9138                        exitRule();
9139                }
9140                return _localctx;
9141        }
9142
9143        public static class OptionContext extends ParserRuleContext {
9144                public OptionTagOpenContext optionTagOpen() {
9145                        return getRuleContext(OptionTagOpenContext.class,0);
9146                }
9147                public OptionTagCloseContext optionTagClose() {
9148                        return getRuleContext(OptionTagCloseContext.class,0);
9149                }
9150                public List<HtmlTagContext> htmlTag() {
9151                        return getRuleContexts(HtmlTagContext.class);
9152                }
9153                public HtmlTagContext htmlTag(int i) {
9154                        return getRuleContext(HtmlTagContext.class,i);
9155                }
9156                public List<SingletonTagContext> singletonTag() {
9157                        return getRuleContexts(SingletonTagContext.class);
9158                }
9159                public SingletonTagContext singletonTag(int i) {
9160                        return getRuleContext(SingletonTagContext.class,i);
9161                }
9162                public List<ParagraphContext> paragraph() {
9163                        return getRuleContexts(ParagraphContext.class);
9164                }
9165                public ParagraphContext paragraph(int i) {
9166                        return getRuleContext(ParagraphContext.class,i);
9167                }
9168                public List<LiContext> li() {
9169                        return getRuleContexts(LiContext.class);
9170                }
9171                public LiContext li(int i) {
9172                        return getRuleContext(LiContext.class,i);
9173                }
9174                public List<TrContext> tr() {
9175                        return getRuleContexts(TrContext.class);
9176                }
9177                public TrContext tr(int i) {
9178                        return getRuleContext(TrContext.class,i);
9179                }
9180                public List<TdContext> td() {
9181                        return getRuleContexts(TdContext.class);
9182                }
9183                public TdContext td(int i) {
9184                        return getRuleContext(TdContext.class,i);
9185                }
9186                public List<ThContext> th() {
9187                        return getRuleContexts(ThContext.class);
9188                }
9189                public ThContext th(int i) {
9190                        return getRuleContext(ThContext.class,i);
9191                }
9192                public List<BodyContext> body() {
9193                        return getRuleContexts(BodyContext.class);
9194                }
9195                public BodyContext body(int i) {
9196                        return getRuleContext(BodyContext.class,i);
9197                }
9198                public List<ColgroupContext> colgroup() {
9199                        return getRuleContexts(ColgroupContext.class);
9200                }
9201                public ColgroupContext colgroup(int i) {
9202                        return getRuleContext(ColgroupContext.class,i);
9203                }
9204                public List<DdContext> dd() {
9205                        return getRuleContexts(DdContext.class);
9206                }
9207                public DdContext dd(int i) {
9208                        return getRuleContext(DdContext.class,i);
9209                }
9210                public List<DtContext> dt() {
9211                        return getRuleContexts(DtContext.class);
9212                }
9213                public DtContext dt(int i) {
9214                        return getRuleContext(DtContext.class,i);
9215                }
9216                public List<HeadContext> head() {
9217                        return getRuleContexts(HeadContext.class);
9218                }
9219                public HeadContext head(int i) {
9220                        return getRuleContext(HeadContext.class,i);
9221                }
9222                public List<HtmlContext> html() {
9223                        return getRuleContexts(HtmlContext.class);
9224                }
9225                public HtmlContext html(int i) {
9226                        return getRuleContext(HtmlContext.class,i);
9227                }
9228                public List<TbodyContext> tbody() {
9229                        return getRuleContexts(TbodyContext.class);
9230                }
9231                public TbodyContext tbody(int i) {
9232                        return getRuleContext(TbodyContext.class,i);
9233                }
9234                public List<TheadContext> thead() {
9235                        return getRuleContexts(TheadContext.class);
9236                }
9237                public TheadContext thead(int i) {
9238                        return getRuleContext(TheadContext.class,i);
9239                }
9240                public List<TfootContext> tfoot() {
9241                        return getRuleContexts(TfootContext.class);
9242                }
9243                public TfootContext tfoot(int i) {
9244                        return getRuleContext(TfootContext.class,i);
9245                }
9246                public List<PTagOpenContext> pTagOpen() {
9247                        return getRuleContexts(PTagOpenContext.class);
9248                }
9249                public PTagOpenContext pTagOpen(int i) {
9250                        return getRuleContext(PTagOpenContext.class,i);
9251                }
9252                public List<LiTagOpenContext> liTagOpen() {
9253                        return getRuleContexts(LiTagOpenContext.class);
9254                }
9255                public LiTagOpenContext liTagOpen(int i) {
9256                        return getRuleContext(LiTagOpenContext.class,i);
9257                }
9258                public List<TrTagOpenContext> trTagOpen() {
9259                        return getRuleContexts(TrTagOpenContext.class);
9260                }
9261                public TrTagOpenContext trTagOpen(int i) {
9262                        return getRuleContext(TrTagOpenContext.class,i);
9263                }
9264                public List<TdTagOpenContext> tdTagOpen() {
9265                        return getRuleContexts(TdTagOpenContext.class);
9266                }
9267                public TdTagOpenContext tdTagOpen(int i) {
9268                        return getRuleContext(TdTagOpenContext.class,i);
9269                }
9270                public List<ThTagOpenContext> thTagOpen() {
9271                        return getRuleContexts(ThTagOpenContext.class);
9272                }
9273                public ThTagOpenContext thTagOpen(int i) {
9274                        return getRuleContext(ThTagOpenContext.class,i);
9275                }
9276                public List<BodyTagOpenContext> bodyTagOpen() {
9277                        return getRuleContexts(BodyTagOpenContext.class);
9278                }
9279                public BodyTagOpenContext bodyTagOpen(int i) {
9280                        return getRuleContext(BodyTagOpenContext.class,i);
9281                }
9282                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9283                        return getRuleContexts(ColgroupTagOpenContext.class);
9284                }
9285                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9286                        return getRuleContext(ColgroupTagOpenContext.class,i);
9287                }
9288                public List<DdTagOpenContext> ddTagOpen() {
9289                        return getRuleContexts(DdTagOpenContext.class);
9290                }
9291                public DdTagOpenContext ddTagOpen(int i) {
9292                        return getRuleContext(DdTagOpenContext.class,i);
9293                }
9294                public List<DtTagOpenContext> dtTagOpen() {
9295                        return getRuleContexts(DtTagOpenContext.class);
9296                }
9297                public DtTagOpenContext dtTagOpen(int i) {
9298                        return getRuleContext(DtTagOpenContext.class,i);
9299                }
9300                public List<HeadTagOpenContext> headTagOpen() {
9301                        return getRuleContexts(HeadTagOpenContext.class);
9302                }
9303                public HeadTagOpenContext headTagOpen(int i) {
9304                        return getRuleContext(HeadTagOpenContext.class,i);
9305                }
9306                public List<HtmlTagOpenContext> htmlTagOpen() {
9307                        return getRuleContexts(HtmlTagOpenContext.class);
9308                }
9309                public HtmlTagOpenContext htmlTagOpen(int i) {
9310                        return getRuleContext(HtmlTagOpenContext.class,i);
9311                }
9312                public List<TbodyTagOpenContext> tbodyTagOpen() {
9313                        return getRuleContexts(TbodyTagOpenContext.class);
9314                }
9315                public TbodyTagOpenContext tbodyTagOpen(int i) {
9316                        return getRuleContext(TbodyTagOpenContext.class,i);
9317                }
9318                public List<TheadTagOpenContext> theadTagOpen() {
9319                        return getRuleContexts(TheadTagOpenContext.class);
9320                }
9321                public TheadTagOpenContext theadTagOpen(int i) {
9322                        return getRuleContext(TheadTagOpenContext.class,i);
9323                }
9324                public List<TfootTagOpenContext> tfootTagOpen() {
9325                        return getRuleContexts(TfootTagOpenContext.class);
9326                }
9327                public TfootTagOpenContext tfootTagOpen(int i) {
9328                        return getRuleContext(TfootTagOpenContext.class,i);
9329                }
9330                public List<HtmlCommentContext> htmlComment() {
9331                        return getRuleContexts(HtmlCommentContext.class);
9332                }
9333                public HtmlCommentContext htmlComment(int i) {
9334                        return getRuleContext(HtmlCommentContext.class,i);
9335                }
9336                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9337                public TerminalNode CDATA(int i) {
9338                        return getToken(JavadocParser.CDATA, i);
9339                }
9340                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9341                public TerminalNode NEWLINE(int i) {
9342                        return getToken(JavadocParser.NEWLINE, i);
9343                }
9344                public List<TextContext> text() {
9345                        return getRuleContexts(TextContext.class);
9346                }
9347                public TextContext text(int i) {
9348                        return getRuleContext(TextContext.class,i);
9349                }
9350                public List<JavadocInlineTagContext> javadocInlineTag() {
9351                        return getRuleContexts(JavadocInlineTagContext.class);
9352                }
9353                public JavadocInlineTagContext javadocInlineTag(int i) {
9354                        return getRuleContext(JavadocInlineTagContext.class,i);
9355                }
9356                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9357                public TerminalNode LEADING_ASTERISK(int i) {
9358                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9359                }
9360                public OptionContext(ParserRuleContext parent, int invokingState) {
9361                        super(parent, invokingState);
9362                }
9363                @Override public int getRuleIndex() { return RULE_option; }
9364                @Override
9365                public void enterRule(ParseTreeListener listener) {
9366                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this);
9367                }
9368                @Override
9369                public void exitRule(ParseTreeListener listener) {
9370                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this);
9371                }
9372                @Override
9373                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9374                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this);
9375                        else return visitor.visitChildren(this);
9376                }
9377        }
9378
9379        public final OptionContext option() throws RecognitionException {
9380                OptionContext _localctx = new OptionContext(_ctx, getState());
9381                enterRule(_localctx, 82, RULE_option);
9382                try {
9383                        int _alt;
9384                        enterOuterAlt(_localctx, 1);
9385                        {
9386                        setState(1089);
9387                        optionTagOpen();
9388                        setState(1129);
9389                        _errHandler.sync(this);
9390                        _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9391                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9392                                if ( _alt==1 ) {
9393                                        {
9394                                        setState(1127);
9395                                        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
9396                                        case 1:
9397                                                {
9398                                                setState(1090);
9399                                                htmlTag();
9400                                                }
9401                                                break;
9402                                        case 2:
9403                                                {
9404                                                setState(1091);
9405                                                singletonTag();
9406                                                }
9407                                                break;
9408                                        case 3:
9409                                                {
9410                                                setState(1092);
9411                                                paragraph();
9412                                                }
9413                                                break;
9414                                        case 4:
9415                                                {
9416                                                setState(1093);
9417                                                li();
9418                                                }
9419                                                break;
9420                                        case 5:
9421                                                {
9422                                                setState(1094);
9423                                                tr();
9424                                                }
9425                                                break;
9426                                        case 6:
9427                                                {
9428                                                setState(1095);
9429                                                td();
9430                                                }
9431                                                break;
9432                                        case 7:
9433                                                {
9434                                                setState(1096);
9435                                                th();
9436                                                }
9437                                                break;
9438                                        case 8:
9439                                                {
9440                                                setState(1097);
9441                                                body();
9442                                                }
9443                                                break;
9444                                        case 9:
9445                                                {
9446                                                setState(1098);
9447                                                colgroup();
9448                                                }
9449                                                break;
9450                                        case 10:
9451                                                {
9452                                                setState(1099);
9453                                                dd();
9454                                                }
9455                                                break;
9456                                        case 11:
9457                                                {
9458                                                setState(1100);
9459                                                dt();
9460                                                }
9461                                                break;
9462                                        case 12:
9463                                                {
9464                                                setState(1101);
9465                                                head();
9466                                                }
9467                                                break;
9468                                        case 13:
9469                                                {
9470                                                setState(1102);
9471                                                html();
9472                                                }
9473                                                break;
9474                                        case 14:
9475                                                {
9476                                                setState(1103);
9477                                                tbody();
9478                                                }
9479                                                break;
9480                                        case 15:
9481                                                {
9482                                                setState(1104);
9483                                                thead();
9484                                                }
9485                                                break;
9486                                        case 16:
9487                                                {
9488                                                setState(1105);
9489                                                tfoot();
9490                                                }
9491                                                break;
9492                                        case 17:
9493                                                {
9494                                                setState(1106);
9495                                                pTagOpen();
9496                                                }
9497                                                break;
9498                                        case 18:
9499                                                {
9500                                                setState(1107);
9501                                                liTagOpen();
9502                                                }
9503                                                break;
9504                                        case 19:
9505                                                {
9506                                                setState(1108);
9507                                                trTagOpen();
9508                                                }
9509                                                break;
9510                                        case 20:
9511                                                {
9512                                                setState(1109);
9513                                                tdTagOpen();
9514                                                }
9515                                                break;
9516                                        case 21:
9517                                                {
9518                                                setState(1110);
9519                                                thTagOpen();
9520                                                }
9521                                                break;
9522                                        case 22:
9523                                                {
9524                                                setState(1111);
9525                                                bodyTagOpen();
9526                                                }
9527                                                break;
9528                                        case 23:
9529                                                {
9530                                                setState(1112);
9531                                                colgroupTagOpen();
9532                                                }
9533                                                break;
9534                                        case 24:
9535                                                {
9536                                                setState(1113);
9537                                                ddTagOpen();
9538                                                }
9539                                                break;
9540                                        case 25:
9541                                                {
9542                                                setState(1114);
9543                                                dtTagOpen();
9544                                                }
9545                                                break;
9546                                        case 26:
9547                                                {
9548                                                setState(1115);
9549                                                headTagOpen();
9550                                                }
9551                                                break;
9552                                        case 27:
9553                                                {
9554                                                setState(1116);
9555                                                htmlTagOpen();
9556                                                }
9557                                                break;
9558                                        case 28:
9559                                                {
9560                                                setState(1117);
9561                                                tbodyTagOpen();
9562                                                }
9563                                                break;
9564                                        case 29:
9565                                                {
9566                                                setState(1118);
9567                                                theadTagOpen();
9568                                                }
9569                                                break;
9570                                        case 30:
9571                                                {
9572                                                setState(1119);
9573                                                tfootTagOpen();
9574                                                }
9575                                                break;
9576                                        case 31:
9577                                                {
9578                                                {
9579                                                setState(1120);
9580                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9581                                                setState(1121);
9582                                                match(LEADING_ASTERISK);
9583                                                }
9584                                                }
9585                                                break;
9586                                        case 32:
9587                                                {
9588                                                setState(1122);
9589                                                htmlComment();
9590                                                }
9591                                                break;
9592                                        case 33:
9593                                                {
9594                                                setState(1123);
9595                                                match(CDATA);
9596                                                }
9597                                                break;
9598                                        case 34:
9599                                                {
9600                                                setState(1124);
9601                                                match(NEWLINE);
9602                                                }
9603                                                break;
9604                                        case 35:
9605                                                {
9606                                                setState(1125);
9607                                                text();
9608                                                }
9609                                                break;
9610                                        case 36:
9611                                                {
9612                                                setState(1126);
9613                                                javadocInlineTag();
9614                                                }
9615                                                break;
9616                                        }
9617                                        } 
9618                                }
9619                                setState(1131);
9620                                _errHandler.sync(this);
9621                                _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9622                        }
9623                        setState(1132);
9624                        optionTagClose();
9625                        }
9626                }
9627                catch (RecognitionException re) {
9628                        _localctx.exception = re;
9629                        _errHandler.reportError(this, re);
9630                        _errHandler.recover(this, re);
9631                }
9632                finally {
9633                        exitRule();
9634                }
9635                return _localctx;
9636        }
9637
9638        public static class TbodyTagOpenContext extends ParserRuleContext {
9639                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9640                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9641                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9642                public List<AttributeContext> attribute() {
9643                        return getRuleContexts(AttributeContext.class);
9644                }
9645                public AttributeContext attribute(int i) {
9646                        return getRuleContext(AttributeContext.class,i);
9647                }
9648                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9649                public TerminalNode NEWLINE(int i) {
9650                        return getToken(JavadocParser.NEWLINE, i);
9651                }
9652                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9653                public TerminalNode LEADING_ASTERISK(int i) {
9654                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9655                }
9656                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9657                public TerminalNode WS(int i) {
9658                        return getToken(JavadocParser.WS, i);
9659                }
9660                public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) {
9661                        super(parent, invokingState);
9662                }
9663                @Override public int getRuleIndex() { return RULE_tbodyTagOpen; }
9664                @Override
9665                public void enterRule(ParseTreeListener listener) {
9666                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this);
9667                }
9668                @Override
9669                public void exitRule(ParseTreeListener listener) {
9670                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this);
9671                }
9672                @Override
9673                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9674                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this);
9675                        else return visitor.visitChildren(this);
9676                }
9677        }
9678
9679        public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException {
9680                TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState());
9681                enterRule(_localctx, 84, RULE_tbodyTagOpen);
9682                int _la;
9683                try {
9684                        enterOuterAlt(_localctx, 1);
9685                        {
9686                        setState(1134);
9687                        match(OPEN);
9688                        setState(1135);
9689                        match(TBODY_HTML_TAG_NAME);
9690                        setState(1142);
9691                        _errHandler.sync(this);
9692                        _la = _input.LA(1);
9693                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9694                                {
9695                                setState(1140);
9696                                switch (_input.LA(1)) {
9697                                case HTML_TAG_NAME:
9698                                        {
9699                                        setState(1136);
9700                                        attribute();
9701                                        }
9702                                        break;
9703                                case NEWLINE:
9704                                        {
9705                                        setState(1137);
9706                                        match(NEWLINE);
9707                                        }
9708                                        break;
9709                                case LEADING_ASTERISK:
9710                                        {
9711                                        setState(1138);
9712                                        match(LEADING_ASTERISK);
9713                                        }
9714                                        break;
9715                                case WS:
9716                                        {
9717                                        setState(1139);
9718                                        match(WS);
9719                                        }
9720                                        break;
9721                                default:
9722                                        throw new NoViableAltException(this);
9723                                }
9724                                }
9725                                setState(1144);
9726                                _errHandler.sync(this);
9727                                _la = _input.LA(1);
9728                        }
9729                        setState(1145);
9730                        match(CLOSE);
9731                        }
9732                }
9733                catch (RecognitionException re) {
9734                        _localctx.exception = re;
9735                        _errHandler.reportError(this, re);
9736                        _errHandler.recover(this, re);
9737                }
9738                finally {
9739                        exitRule();
9740                }
9741                return _localctx;
9742        }
9743
9744        public static class TbodyTagCloseContext extends ParserRuleContext {
9745                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9746                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9747                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9748                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9749                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9750                public TerminalNode NEWLINE(int i) {
9751                        return getToken(JavadocParser.NEWLINE, i);
9752                }
9753                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9754                public TerminalNode LEADING_ASTERISK(int i) {
9755                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9756                }
9757                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9758                public TerminalNode WS(int i) {
9759                        return getToken(JavadocParser.WS, i);
9760                }
9761                public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) {
9762                        super(parent, invokingState);
9763                }
9764                @Override public int getRuleIndex() { return RULE_tbodyTagClose; }
9765                @Override
9766                public void enterRule(ParseTreeListener listener) {
9767                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this);
9768                }
9769                @Override
9770                public void exitRule(ParseTreeListener listener) {
9771                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this);
9772                }
9773                @Override
9774                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9775                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this);
9776                        else return visitor.visitChildren(this);
9777                }
9778        }
9779
9780        public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException {
9781                TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState());
9782                enterRule(_localctx, 86, RULE_tbodyTagClose);
9783                int _la;
9784                try {
9785                        enterOuterAlt(_localctx, 1);
9786                        {
9787                        setState(1147);
9788                        match(OPEN);
9789                        setState(1148);
9790                        match(SLASH);
9791                        setState(1149);
9792                        match(TBODY_HTML_TAG_NAME);
9793                        setState(1153);
9794                        _errHandler.sync(this);
9795                        _la = _input.LA(1);
9796                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9797                                {
9798                                {
9799                                setState(1150);
9800                                _la = _input.LA(1);
9801                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9802                                _errHandler.recoverInline(this);
9803                                } else {
9804                                        consume();
9805                                }
9806                                }
9807                                }
9808                                setState(1155);
9809                                _errHandler.sync(this);
9810                                _la = _input.LA(1);
9811                        }
9812                        setState(1156);
9813                        match(CLOSE);
9814                        }
9815                }
9816                catch (RecognitionException re) {
9817                        _localctx.exception = re;
9818                        _errHandler.reportError(this, re);
9819                        _errHandler.recover(this, re);
9820                }
9821                finally {
9822                        exitRule();
9823                }
9824                return _localctx;
9825        }
9826
9827        public static class TbodyContext extends ParserRuleContext {
9828                public TbodyTagOpenContext tbodyTagOpen() {
9829                        return getRuleContext(TbodyTagOpenContext.class,0);
9830                }
9831                public TbodyTagCloseContext tbodyTagClose() {
9832                        return getRuleContext(TbodyTagCloseContext.class,0);
9833                }
9834                public List<HtmlTagContext> htmlTag() {
9835                        return getRuleContexts(HtmlTagContext.class);
9836                }
9837                public HtmlTagContext htmlTag(int i) {
9838                        return getRuleContext(HtmlTagContext.class,i);
9839                }
9840                public List<SingletonTagContext> singletonTag() {
9841                        return getRuleContexts(SingletonTagContext.class);
9842                }
9843                public SingletonTagContext singletonTag(int i) {
9844                        return getRuleContext(SingletonTagContext.class,i);
9845                }
9846                public List<ParagraphContext> paragraph() {
9847                        return getRuleContexts(ParagraphContext.class);
9848                }
9849                public ParagraphContext paragraph(int i) {
9850                        return getRuleContext(ParagraphContext.class,i);
9851                }
9852                public List<LiContext> li() {
9853                        return getRuleContexts(LiContext.class);
9854                }
9855                public LiContext li(int i) {
9856                        return getRuleContext(LiContext.class,i);
9857                }
9858                public List<TrContext> tr() {
9859                        return getRuleContexts(TrContext.class);
9860                }
9861                public TrContext tr(int i) {
9862                        return getRuleContext(TrContext.class,i);
9863                }
9864                public List<TdContext> td() {
9865                        return getRuleContexts(TdContext.class);
9866                }
9867                public TdContext td(int i) {
9868                        return getRuleContext(TdContext.class,i);
9869                }
9870                public List<ThContext> th() {
9871                        return getRuleContexts(ThContext.class);
9872                }
9873                public ThContext th(int i) {
9874                        return getRuleContext(ThContext.class,i);
9875                }
9876                public List<BodyContext> body() {
9877                        return getRuleContexts(BodyContext.class);
9878                }
9879                public BodyContext body(int i) {
9880                        return getRuleContext(BodyContext.class,i);
9881                }
9882                public List<ColgroupContext> colgroup() {
9883                        return getRuleContexts(ColgroupContext.class);
9884                }
9885                public ColgroupContext colgroup(int i) {
9886                        return getRuleContext(ColgroupContext.class,i);
9887                }
9888                public List<DdContext> dd() {
9889                        return getRuleContexts(DdContext.class);
9890                }
9891                public DdContext dd(int i) {
9892                        return getRuleContext(DdContext.class,i);
9893                }
9894                public List<DtContext> dt() {
9895                        return getRuleContexts(DtContext.class);
9896                }
9897                public DtContext dt(int i) {
9898                        return getRuleContext(DtContext.class,i);
9899                }
9900                public List<HeadContext> head() {
9901                        return getRuleContexts(HeadContext.class);
9902                }
9903                public HeadContext head(int i) {
9904                        return getRuleContext(HeadContext.class,i);
9905                }
9906                public List<HtmlContext> html() {
9907                        return getRuleContexts(HtmlContext.class);
9908                }
9909                public HtmlContext html(int i) {
9910                        return getRuleContext(HtmlContext.class,i);
9911                }
9912                public List<OptionContext> option() {
9913                        return getRuleContexts(OptionContext.class);
9914                }
9915                public OptionContext option(int i) {
9916                        return getRuleContext(OptionContext.class,i);
9917                }
9918                public List<TheadContext> thead() {
9919                        return getRuleContexts(TheadContext.class);
9920                }
9921                public TheadContext thead(int i) {
9922                        return getRuleContext(TheadContext.class,i);
9923                }
9924                public List<TfootContext> tfoot() {
9925                        return getRuleContexts(TfootContext.class);
9926                }
9927                public TfootContext tfoot(int i) {
9928                        return getRuleContext(TfootContext.class,i);
9929                }
9930                public List<PTagOpenContext> pTagOpen() {
9931                        return getRuleContexts(PTagOpenContext.class);
9932                }
9933                public PTagOpenContext pTagOpen(int i) {
9934                        return getRuleContext(PTagOpenContext.class,i);
9935                }
9936                public List<LiTagOpenContext> liTagOpen() {
9937                        return getRuleContexts(LiTagOpenContext.class);
9938                }
9939                public LiTagOpenContext liTagOpen(int i) {
9940                        return getRuleContext(LiTagOpenContext.class,i);
9941                }
9942                public List<TrTagOpenContext> trTagOpen() {
9943                        return getRuleContexts(TrTagOpenContext.class);
9944                }
9945                public TrTagOpenContext trTagOpen(int i) {
9946                        return getRuleContext(TrTagOpenContext.class,i);
9947                }
9948                public List<TdTagOpenContext> tdTagOpen() {
9949                        return getRuleContexts(TdTagOpenContext.class);
9950                }
9951                public TdTagOpenContext tdTagOpen(int i) {
9952                        return getRuleContext(TdTagOpenContext.class,i);
9953                }
9954                public List<ThTagOpenContext> thTagOpen() {
9955                        return getRuleContexts(ThTagOpenContext.class);
9956                }
9957                public ThTagOpenContext thTagOpen(int i) {
9958                        return getRuleContext(ThTagOpenContext.class,i);
9959                }
9960                public List<BodyTagOpenContext> bodyTagOpen() {
9961                        return getRuleContexts(BodyTagOpenContext.class);
9962                }
9963                public BodyTagOpenContext bodyTagOpen(int i) {
9964                        return getRuleContext(BodyTagOpenContext.class,i);
9965                }
9966                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9967                        return getRuleContexts(ColgroupTagOpenContext.class);
9968                }
9969                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9970                        return getRuleContext(ColgroupTagOpenContext.class,i);
9971                }
9972                public List<DdTagOpenContext> ddTagOpen() {
9973                        return getRuleContexts(DdTagOpenContext.class);
9974                }
9975                public DdTagOpenContext ddTagOpen(int i) {
9976                        return getRuleContext(DdTagOpenContext.class,i);
9977                }
9978                public List<DtTagOpenContext> dtTagOpen() {
9979                        return getRuleContexts(DtTagOpenContext.class);
9980                }
9981                public DtTagOpenContext dtTagOpen(int i) {
9982                        return getRuleContext(DtTagOpenContext.class,i);
9983                }
9984                public List<HeadTagOpenContext> headTagOpen() {
9985                        return getRuleContexts(HeadTagOpenContext.class);
9986                }
9987                public HeadTagOpenContext headTagOpen(int i) {
9988                        return getRuleContext(HeadTagOpenContext.class,i);
9989                }
9990                public List<HtmlTagOpenContext> htmlTagOpen() {
9991                        return getRuleContexts(HtmlTagOpenContext.class);
9992                }
9993                public HtmlTagOpenContext htmlTagOpen(int i) {
9994                        return getRuleContext(HtmlTagOpenContext.class,i);
9995                }
9996                public List<OptionTagOpenContext> optionTagOpen() {
9997                        return getRuleContexts(OptionTagOpenContext.class);
9998                }
9999                public OptionTagOpenContext optionTagOpen(int i) {
10000                        return getRuleContext(OptionTagOpenContext.class,i);
10001                }
10002                public List<TheadTagOpenContext> theadTagOpen() {
10003                        return getRuleContexts(TheadTagOpenContext.class);
10004                }
10005                public TheadTagOpenContext theadTagOpen(int i) {
10006                        return getRuleContext(TheadTagOpenContext.class,i);
10007                }
10008                public List<TfootTagOpenContext> tfootTagOpen() {
10009                        return getRuleContexts(TfootTagOpenContext.class);
10010                }
10011                public TfootTagOpenContext tfootTagOpen(int i) {
10012                        return getRuleContext(TfootTagOpenContext.class,i);
10013                }
10014                public List<HtmlCommentContext> htmlComment() {
10015                        return getRuleContexts(HtmlCommentContext.class);
10016                }
10017                public HtmlCommentContext htmlComment(int i) {
10018                        return getRuleContext(HtmlCommentContext.class,i);
10019                }
10020                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10021                public TerminalNode CDATA(int i) {
10022                        return getToken(JavadocParser.CDATA, i);
10023                }
10024                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10025                public TerminalNode NEWLINE(int i) {
10026                        return getToken(JavadocParser.NEWLINE, i);
10027                }
10028                public List<TextContext> text() {
10029                        return getRuleContexts(TextContext.class);
10030                }
10031                public TextContext text(int i) {
10032                        return getRuleContext(TextContext.class,i);
10033                }
10034                public List<JavadocInlineTagContext> javadocInlineTag() {
10035                        return getRuleContexts(JavadocInlineTagContext.class);
10036                }
10037                public JavadocInlineTagContext javadocInlineTag(int i) {
10038                        return getRuleContext(JavadocInlineTagContext.class,i);
10039                }
10040                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10041                public TerminalNode LEADING_ASTERISK(int i) {
10042                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10043                }
10044                public TbodyContext(ParserRuleContext parent, int invokingState) {
10045                        super(parent, invokingState);
10046                }
10047                @Override public int getRuleIndex() { return RULE_tbody; }
10048                @Override
10049                public void enterRule(ParseTreeListener listener) {
10050                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this);
10051                }
10052                @Override
10053                public void exitRule(ParseTreeListener listener) {
10054                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this);
10055                }
10056                @Override
10057                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10058                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this);
10059                        else return visitor.visitChildren(this);
10060                }
10061        }
10062
10063        public final TbodyContext tbody() throws RecognitionException {
10064                TbodyContext _localctx = new TbodyContext(_ctx, getState());
10065                enterRule(_localctx, 88, RULE_tbody);
10066                try {
10067                        int _alt;
10068                        enterOuterAlt(_localctx, 1);
10069                        {
10070                        setState(1158);
10071                        tbodyTagOpen();
10072                        setState(1198);
10073                        _errHandler.sync(this);
10074                        _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10075                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10076                                if ( _alt==1 ) {
10077                                        {
10078                                        setState(1196);
10079                                        switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
10080                                        case 1:
10081                                                {
10082                                                setState(1159);
10083                                                htmlTag();
10084                                                }
10085                                                break;
10086                                        case 2:
10087                                                {
10088                                                setState(1160);
10089                                                singletonTag();
10090                                                }
10091                                                break;
10092                                        case 3:
10093                                                {
10094                                                setState(1161);
10095                                                paragraph();
10096                                                }
10097                                                break;
10098                                        case 4:
10099                                                {
10100                                                setState(1162);
10101                                                li();
10102                                                }
10103                                                break;
10104                                        case 5:
10105                                                {
10106                                                setState(1163);
10107                                                tr();
10108                                                }
10109                                                break;
10110                                        case 6:
10111                                                {
10112                                                setState(1164);
10113                                                td();
10114                                                }
10115                                                break;
10116                                        case 7:
10117                                                {
10118                                                setState(1165);
10119                                                th();
10120                                                }
10121                                                break;
10122                                        case 8:
10123                                                {
10124                                                setState(1166);
10125                                                body();
10126                                                }
10127                                                break;
10128                                        case 9:
10129                                                {
10130                                                setState(1167);
10131                                                colgroup();
10132                                                }
10133                                                break;
10134                                        case 10:
10135                                                {
10136                                                setState(1168);
10137                                                dd();
10138                                                }
10139                                                break;
10140                                        case 11:
10141                                                {
10142                                                setState(1169);
10143                                                dt();
10144                                                }
10145                                                break;
10146                                        case 12:
10147                                                {
10148                                                setState(1170);
10149                                                head();
10150                                                }
10151                                                break;
10152                                        case 13:
10153                                                {
10154                                                setState(1171);
10155                                                html();
10156                                                }
10157                                                break;
10158                                        case 14:
10159                                                {
10160                                                setState(1172);
10161                                                option();
10162                                                }
10163                                                break;
10164                                        case 15:
10165                                                {
10166                                                setState(1173);
10167                                                thead();
10168                                                }
10169                                                break;
10170                                        case 16:
10171                                                {
10172                                                setState(1174);
10173                                                tfoot();
10174                                                }
10175                                                break;
10176                                        case 17:
10177                                                {
10178                                                setState(1175);
10179                                                pTagOpen();
10180                                                }
10181                                                break;
10182                                        case 18:
10183                                                {
10184                                                setState(1176);
10185                                                liTagOpen();
10186                                                }
10187                                                break;
10188                                        case 19:
10189                                                {
10190                                                setState(1177);
10191                                                trTagOpen();
10192                                                }
10193                                                break;
10194                                        case 20:
10195                                                {
10196                                                setState(1178);
10197                                                tdTagOpen();
10198                                                }
10199                                                break;
10200                                        case 21:
10201                                                {
10202                                                setState(1179);
10203                                                thTagOpen();
10204                                                }
10205                                                break;
10206                                        case 22:
10207                                                {
10208                                                setState(1180);
10209                                                bodyTagOpen();
10210                                                }
10211                                                break;
10212                                        case 23:
10213                                                {
10214                                                setState(1181);
10215                                                colgroupTagOpen();
10216                                                }
10217                                                break;
10218                                        case 24:
10219                                                {
10220                                                setState(1182);
10221                                                ddTagOpen();
10222                                                }
10223                                                break;
10224                                        case 25:
10225                                                {
10226                                                setState(1183);
10227                                                dtTagOpen();
10228                                                }
10229                                                break;
10230                                        case 26:
10231                                                {
10232                                                setState(1184);
10233                                                headTagOpen();
10234                                                }
10235                                                break;
10236                                        case 27:
10237                                                {
10238                                                setState(1185);
10239                                                htmlTagOpen();
10240                                                }
10241                                                break;
10242                                        case 28:
10243                                                {
10244                                                setState(1186);
10245                                                optionTagOpen();
10246                                                }
10247                                                break;
10248                                        case 29:
10249                                                {
10250                                                setState(1187);
10251                                                theadTagOpen();
10252                                                }
10253                                                break;
10254                                        case 30:
10255                                                {
10256                                                setState(1188);
10257                                                tfootTagOpen();
10258                                                }
10259                                                break;
10260                                        case 31:
10261                                                {
10262                                                {
10263                                                setState(1189);
10264                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10265                                                setState(1190);
10266                                                match(LEADING_ASTERISK);
10267                                                }
10268                                                }
10269                                                break;
10270                                        case 32:
10271                                                {
10272                                                setState(1191);
10273                                                htmlComment();
10274                                                }
10275                                                break;
10276                                        case 33:
10277                                                {
10278                                                setState(1192);
10279                                                match(CDATA);
10280                                                }
10281                                                break;
10282                                        case 34:
10283                                                {
10284                                                setState(1193);
10285                                                match(NEWLINE);
10286                                                }
10287                                                break;
10288                                        case 35:
10289                                                {
10290                                                setState(1194);
10291                                                text();
10292                                                }
10293                                                break;
10294                                        case 36:
10295                                                {
10296                                                setState(1195);
10297                                                javadocInlineTag();
10298                                                }
10299                                                break;
10300                                        }
10301                                        } 
10302                                }
10303                                setState(1200);
10304                                _errHandler.sync(this);
10305                                _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10306                        }
10307                        setState(1201);
10308                        tbodyTagClose();
10309                        }
10310                }
10311                catch (RecognitionException re) {
10312                        _localctx.exception = re;
10313                        _errHandler.reportError(this, re);
10314                        _errHandler.recover(this, re);
10315                }
10316                finally {
10317                        exitRule();
10318                }
10319                return _localctx;
10320        }
10321
10322        public static class TfootTagOpenContext extends ParserRuleContext {
10323                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10324                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10325                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10326                public List<AttributeContext> attribute() {
10327                        return getRuleContexts(AttributeContext.class);
10328                }
10329                public AttributeContext attribute(int i) {
10330                        return getRuleContext(AttributeContext.class,i);
10331                }
10332                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10333                public TerminalNode NEWLINE(int i) {
10334                        return getToken(JavadocParser.NEWLINE, i);
10335                }
10336                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10337                public TerminalNode LEADING_ASTERISK(int i) {
10338                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10339                }
10340                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10341                public TerminalNode WS(int i) {
10342                        return getToken(JavadocParser.WS, i);
10343                }
10344                public TfootTagOpenContext(ParserRuleContext parent, int invokingState) {
10345                        super(parent, invokingState);
10346                }
10347                @Override public int getRuleIndex() { return RULE_tfootTagOpen; }
10348                @Override
10349                public void enterRule(ParseTreeListener listener) {
10350                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this);
10351                }
10352                @Override
10353                public void exitRule(ParseTreeListener listener) {
10354                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this);
10355                }
10356                @Override
10357                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10358                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this);
10359                        else return visitor.visitChildren(this);
10360                }
10361        }
10362
10363        public final TfootTagOpenContext tfootTagOpen() throws RecognitionException {
10364                TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState());
10365                enterRule(_localctx, 90, RULE_tfootTagOpen);
10366                int _la;
10367                try {
10368                        enterOuterAlt(_localctx, 1);
10369                        {
10370                        setState(1203);
10371                        match(OPEN);
10372                        setState(1204);
10373                        match(TFOOT_HTML_TAG_NAME);
10374                        setState(1211);
10375                        _errHandler.sync(this);
10376                        _la = _input.LA(1);
10377                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10378                                {
10379                                setState(1209);
10380                                switch (_input.LA(1)) {
10381                                case HTML_TAG_NAME:
10382                                        {
10383                                        setState(1205);
10384                                        attribute();
10385                                        }
10386                                        break;
10387                                case NEWLINE:
10388                                        {
10389                                        setState(1206);
10390                                        match(NEWLINE);
10391                                        }
10392                                        break;
10393                                case LEADING_ASTERISK:
10394                                        {
10395                                        setState(1207);
10396                                        match(LEADING_ASTERISK);
10397                                        }
10398                                        break;
10399                                case WS:
10400                                        {
10401                                        setState(1208);
10402                                        match(WS);
10403                                        }
10404                                        break;
10405                                default:
10406                                        throw new NoViableAltException(this);
10407                                }
10408                                }
10409                                setState(1213);
10410                                _errHandler.sync(this);
10411                                _la = _input.LA(1);
10412                        }
10413                        setState(1214);
10414                        match(CLOSE);
10415                        }
10416                }
10417                catch (RecognitionException re) {
10418                        _localctx.exception = re;
10419                        _errHandler.reportError(this, re);
10420                        _errHandler.recover(this, re);
10421                }
10422                finally {
10423                        exitRule();
10424                }
10425                return _localctx;
10426        }
10427
10428        public static class TfootTagCloseContext extends ParserRuleContext {
10429                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10430                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10431                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10432                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10433                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10434                public TerminalNode NEWLINE(int i) {
10435                        return getToken(JavadocParser.NEWLINE, i);
10436                }
10437                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10438                public TerminalNode LEADING_ASTERISK(int i) {
10439                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10440                }
10441                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10442                public TerminalNode WS(int i) {
10443                        return getToken(JavadocParser.WS, i);
10444                }
10445                public TfootTagCloseContext(ParserRuleContext parent, int invokingState) {
10446                        super(parent, invokingState);
10447                }
10448                @Override public int getRuleIndex() { return RULE_tfootTagClose; }
10449                @Override
10450                public void enterRule(ParseTreeListener listener) {
10451                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this);
10452                }
10453                @Override
10454                public void exitRule(ParseTreeListener listener) {
10455                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this);
10456                }
10457                @Override
10458                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10459                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this);
10460                        else return visitor.visitChildren(this);
10461                }
10462        }
10463
10464        public final TfootTagCloseContext tfootTagClose() throws RecognitionException {
10465                TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState());
10466                enterRule(_localctx, 92, RULE_tfootTagClose);
10467                int _la;
10468                try {
10469                        enterOuterAlt(_localctx, 1);
10470                        {
10471                        setState(1216);
10472                        match(OPEN);
10473                        setState(1217);
10474                        match(SLASH);
10475                        setState(1218);
10476                        match(TFOOT_HTML_TAG_NAME);
10477                        setState(1222);
10478                        _errHandler.sync(this);
10479                        _la = _input.LA(1);
10480                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10481                                {
10482                                {
10483                                setState(1219);
10484                                _la = _input.LA(1);
10485                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10486                                _errHandler.recoverInline(this);
10487                                } else {
10488                                        consume();
10489                                }
10490                                }
10491                                }
10492                                setState(1224);
10493                                _errHandler.sync(this);
10494                                _la = _input.LA(1);
10495                        }
10496                        setState(1225);
10497                        match(CLOSE);
10498                        }
10499                }
10500                catch (RecognitionException re) {
10501                        _localctx.exception = re;
10502                        _errHandler.reportError(this, re);
10503                        _errHandler.recover(this, re);
10504                }
10505                finally {
10506                        exitRule();
10507                }
10508                return _localctx;
10509        }
10510
10511        public static class TfootContext extends ParserRuleContext {
10512                public TfootTagOpenContext tfootTagOpen() {
10513                        return getRuleContext(TfootTagOpenContext.class,0);
10514                }
10515                public TfootTagCloseContext tfootTagClose() {
10516                        return getRuleContext(TfootTagCloseContext.class,0);
10517                }
10518                public List<HtmlTagContext> htmlTag() {
10519                        return getRuleContexts(HtmlTagContext.class);
10520                }
10521                public HtmlTagContext htmlTag(int i) {
10522                        return getRuleContext(HtmlTagContext.class,i);
10523                }
10524                public List<SingletonTagContext> singletonTag() {
10525                        return getRuleContexts(SingletonTagContext.class);
10526                }
10527                public SingletonTagContext singletonTag(int i) {
10528                        return getRuleContext(SingletonTagContext.class,i);
10529                }
10530                public List<ParagraphContext> paragraph() {
10531                        return getRuleContexts(ParagraphContext.class);
10532                }
10533                public ParagraphContext paragraph(int i) {
10534                        return getRuleContext(ParagraphContext.class,i);
10535                }
10536                public List<LiContext> li() {
10537                        return getRuleContexts(LiContext.class);
10538                }
10539                public LiContext li(int i) {
10540                        return getRuleContext(LiContext.class,i);
10541                }
10542                public List<TrContext> tr() {
10543                        return getRuleContexts(TrContext.class);
10544                }
10545                public TrContext tr(int i) {
10546                        return getRuleContext(TrContext.class,i);
10547                }
10548                public List<TdContext> td() {
10549                        return getRuleContexts(TdContext.class);
10550                }
10551                public TdContext td(int i) {
10552                        return getRuleContext(TdContext.class,i);
10553                }
10554                public List<ThContext> th() {
10555                        return getRuleContexts(ThContext.class);
10556                }
10557                public ThContext th(int i) {
10558                        return getRuleContext(ThContext.class,i);
10559                }
10560                public List<BodyContext> body() {
10561                        return getRuleContexts(BodyContext.class);
10562                }
10563                public BodyContext body(int i) {
10564                        return getRuleContext(BodyContext.class,i);
10565                }
10566                public List<ColgroupContext> colgroup() {
10567                        return getRuleContexts(ColgroupContext.class);
10568                }
10569                public ColgroupContext colgroup(int i) {
10570                        return getRuleContext(ColgroupContext.class,i);
10571                }
10572                public List<DdContext> dd() {
10573                        return getRuleContexts(DdContext.class);
10574                }
10575                public DdContext dd(int i) {
10576                        return getRuleContext(DdContext.class,i);
10577                }
10578                public List<DtContext> dt() {
10579                        return getRuleContexts(DtContext.class);
10580                }
10581                public DtContext dt(int i) {
10582                        return getRuleContext(DtContext.class,i);
10583                }
10584                public List<HeadContext> head() {
10585                        return getRuleContexts(HeadContext.class);
10586                }
10587                public HeadContext head(int i) {
10588                        return getRuleContext(HeadContext.class,i);
10589                }
10590                public List<HtmlContext> html() {
10591                        return getRuleContexts(HtmlContext.class);
10592                }
10593                public HtmlContext html(int i) {
10594                        return getRuleContext(HtmlContext.class,i);
10595                }
10596                public List<OptionContext> option() {
10597                        return getRuleContexts(OptionContext.class);
10598                }
10599                public OptionContext option(int i) {
10600                        return getRuleContext(OptionContext.class,i);
10601                }
10602                public List<TbodyContext> tbody() {
10603                        return getRuleContexts(TbodyContext.class);
10604                }
10605                public TbodyContext tbody(int i) {
10606                        return getRuleContext(TbodyContext.class,i);
10607                }
10608                public List<TheadContext> thead() {
10609                        return getRuleContexts(TheadContext.class);
10610                }
10611                public TheadContext thead(int i) {
10612                        return getRuleContext(TheadContext.class,i);
10613                }
10614                public List<PTagOpenContext> pTagOpen() {
10615                        return getRuleContexts(PTagOpenContext.class);
10616                }
10617                public PTagOpenContext pTagOpen(int i) {
10618                        return getRuleContext(PTagOpenContext.class,i);
10619                }
10620                public List<LiTagOpenContext> liTagOpen() {
10621                        return getRuleContexts(LiTagOpenContext.class);
10622                }
10623                public LiTagOpenContext liTagOpen(int i) {
10624                        return getRuleContext(LiTagOpenContext.class,i);
10625                }
10626                public List<TrTagOpenContext> trTagOpen() {
10627                        return getRuleContexts(TrTagOpenContext.class);
10628                }
10629                public TrTagOpenContext trTagOpen(int i) {
10630                        return getRuleContext(TrTagOpenContext.class,i);
10631                }
10632                public List<TdTagOpenContext> tdTagOpen() {
10633                        return getRuleContexts(TdTagOpenContext.class);
10634                }
10635                public TdTagOpenContext tdTagOpen(int i) {
10636                        return getRuleContext(TdTagOpenContext.class,i);
10637                }
10638                public List<ThTagOpenContext> thTagOpen() {
10639                        return getRuleContexts(ThTagOpenContext.class);
10640                }
10641                public ThTagOpenContext thTagOpen(int i) {
10642                        return getRuleContext(ThTagOpenContext.class,i);
10643                }
10644                public List<BodyTagOpenContext> bodyTagOpen() {
10645                        return getRuleContexts(BodyTagOpenContext.class);
10646                }
10647                public BodyTagOpenContext bodyTagOpen(int i) {
10648                        return getRuleContext(BodyTagOpenContext.class,i);
10649                }
10650                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10651                        return getRuleContexts(ColgroupTagOpenContext.class);
10652                }
10653                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10654                        return getRuleContext(ColgroupTagOpenContext.class,i);
10655                }
10656                public List<DdTagOpenContext> ddTagOpen() {
10657                        return getRuleContexts(DdTagOpenContext.class);
10658                }
10659                public DdTagOpenContext ddTagOpen(int i) {
10660                        return getRuleContext(DdTagOpenContext.class,i);
10661                }
10662                public List<DtTagOpenContext> dtTagOpen() {
10663                        return getRuleContexts(DtTagOpenContext.class);
10664                }
10665                public DtTagOpenContext dtTagOpen(int i) {
10666                        return getRuleContext(DtTagOpenContext.class,i);
10667                }
10668                public List<HeadTagOpenContext> headTagOpen() {
10669                        return getRuleContexts(HeadTagOpenContext.class);
10670                }
10671                public HeadTagOpenContext headTagOpen(int i) {
10672                        return getRuleContext(HeadTagOpenContext.class,i);
10673                }
10674                public List<HtmlTagOpenContext> htmlTagOpen() {
10675                        return getRuleContexts(HtmlTagOpenContext.class);
10676                }
10677                public HtmlTagOpenContext htmlTagOpen(int i) {
10678                        return getRuleContext(HtmlTagOpenContext.class,i);
10679                }
10680                public List<OptionTagOpenContext> optionTagOpen() {
10681                        return getRuleContexts(OptionTagOpenContext.class);
10682                }
10683                public OptionTagOpenContext optionTagOpen(int i) {
10684                        return getRuleContext(OptionTagOpenContext.class,i);
10685                }
10686                public List<TbodyTagOpenContext> tbodyTagOpen() {
10687                        return getRuleContexts(TbodyTagOpenContext.class);
10688                }
10689                public TbodyTagOpenContext tbodyTagOpen(int i) {
10690                        return getRuleContext(TbodyTagOpenContext.class,i);
10691                }
10692                public List<TheadTagOpenContext> theadTagOpen() {
10693                        return getRuleContexts(TheadTagOpenContext.class);
10694                }
10695                public TheadTagOpenContext theadTagOpen(int i) {
10696                        return getRuleContext(TheadTagOpenContext.class,i);
10697                }
10698                public List<HtmlCommentContext> htmlComment() {
10699                        return getRuleContexts(HtmlCommentContext.class);
10700                }
10701                public HtmlCommentContext htmlComment(int i) {
10702                        return getRuleContext(HtmlCommentContext.class,i);
10703                }
10704                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10705                public TerminalNode CDATA(int i) {
10706                        return getToken(JavadocParser.CDATA, i);
10707                }
10708                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10709                public TerminalNode NEWLINE(int i) {
10710                        return getToken(JavadocParser.NEWLINE, i);
10711                }
10712                public List<TextContext> text() {
10713                        return getRuleContexts(TextContext.class);
10714                }
10715                public TextContext text(int i) {
10716                        return getRuleContext(TextContext.class,i);
10717                }
10718                public List<JavadocInlineTagContext> javadocInlineTag() {
10719                        return getRuleContexts(JavadocInlineTagContext.class);
10720                }
10721                public JavadocInlineTagContext javadocInlineTag(int i) {
10722                        return getRuleContext(JavadocInlineTagContext.class,i);
10723                }
10724                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10725                public TerminalNode LEADING_ASTERISK(int i) {
10726                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10727                }
10728                public TfootContext(ParserRuleContext parent, int invokingState) {
10729                        super(parent, invokingState);
10730                }
10731                @Override public int getRuleIndex() { return RULE_tfoot; }
10732                @Override
10733                public void enterRule(ParseTreeListener listener) {
10734                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this);
10735                }
10736                @Override
10737                public void exitRule(ParseTreeListener listener) {
10738                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this);
10739                }
10740                @Override
10741                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10742                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this);
10743                        else return visitor.visitChildren(this);
10744                }
10745        }
10746
10747        public final TfootContext tfoot() throws RecognitionException {
10748                TfootContext _localctx = new TfootContext(_ctx, getState());
10749                enterRule(_localctx, 94, RULE_tfoot);
10750                try {
10751                        int _alt;
10752                        enterOuterAlt(_localctx, 1);
10753                        {
10754                        setState(1227);
10755                        tfootTagOpen();
10756                        setState(1267);
10757                        _errHandler.sync(this);
10758                        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10759                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10760                                if ( _alt==1 ) {
10761                                        {
10762                                        setState(1265);
10763                                        switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
10764                                        case 1:
10765                                                {
10766                                                setState(1228);
10767                                                htmlTag();
10768                                                }
10769                                                break;
10770                                        case 2:
10771                                                {
10772                                                setState(1229);
10773                                                singletonTag();
10774                                                }
10775                                                break;
10776                                        case 3:
10777                                                {
10778                                                setState(1230);
10779                                                paragraph();
10780                                                }
10781                                                break;
10782                                        case 4:
10783                                                {
10784                                                setState(1231);
10785                                                li();
10786                                                }
10787                                                break;
10788                                        case 5:
10789                                                {
10790                                                setState(1232);
10791                                                tr();
10792                                                }
10793                                                break;
10794                                        case 6:
10795                                                {
10796                                                setState(1233);
10797                                                td();
10798                                                }
10799                                                break;
10800                                        case 7:
10801                                                {
10802                                                setState(1234);
10803                                                th();
10804                                                }
10805                                                break;
10806                                        case 8:
10807                                                {
10808                                                setState(1235);
10809                                                body();
10810                                                }
10811                                                break;
10812                                        case 9:
10813                                                {
10814                                                setState(1236);
10815                                                colgroup();
10816                                                }
10817                                                break;
10818                                        case 10:
10819                                                {
10820                                                setState(1237);
10821                                                dd();
10822                                                }
10823                                                break;
10824                                        case 11:
10825                                                {
10826                                                setState(1238);
10827                                                dt();
10828                                                }
10829                                                break;
10830                                        case 12:
10831                                                {
10832                                                setState(1239);
10833                                                head();
10834                                                }
10835                                                break;
10836                                        case 13:
10837                                                {
10838                                                setState(1240);
10839                                                html();
10840                                                }
10841                                                break;
10842                                        case 14:
10843                                                {
10844                                                setState(1241);
10845                                                option();
10846                                                }
10847                                                break;
10848                                        case 15:
10849                                                {
10850                                                setState(1242);
10851                                                tbody();
10852                                                }
10853                                                break;
10854                                        case 16:
10855                                                {
10856                                                setState(1243);
10857                                                thead();
10858                                                }
10859                                                break;
10860                                        case 17:
10861                                                {
10862                                                setState(1244);
10863                                                pTagOpen();
10864                                                }
10865                                                break;
10866                                        case 18:
10867                                                {
10868                                                setState(1245);
10869                                                liTagOpen();
10870                                                }
10871                                                break;
10872                                        case 19:
10873                                                {
10874                                                setState(1246);
10875                                                trTagOpen();
10876                                                }
10877                                                break;
10878                                        case 20:
10879                                                {
10880                                                setState(1247);
10881                                                tdTagOpen();
10882                                                }
10883                                                break;
10884                                        case 21:
10885                                                {
10886                                                setState(1248);
10887                                                thTagOpen();
10888                                                }
10889                                                break;
10890                                        case 22:
10891                                                {
10892                                                setState(1249);
10893                                                bodyTagOpen();
10894                                                }
10895                                                break;
10896                                        case 23:
10897                                                {
10898                                                setState(1250);
10899                                                colgroupTagOpen();
10900                                                }
10901                                                break;
10902                                        case 24:
10903                                                {
10904                                                setState(1251);
10905                                                ddTagOpen();
10906                                                }
10907                                                break;
10908                                        case 25:
10909                                                {
10910                                                setState(1252);
10911                                                dtTagOpen();
10912                                                }
10913                                                break;
10914                                        case 26:
10915                                                {
10916                                                setState(1253);
10917                                                headTagOpen();
10918                                                }
10919                                                break;
10920                                        case 27:
10921                                                {
10922                                                setState(1254);
10923                                                htmlTagOpen();
10924                                                }
10925                                                break;
10926                                        case 28:
10927                                                {
10928                                                setState(1255);
10929                                                optionTagOpen();
10930                                                }
10931                                                break;
10932                                        case 29:
10933                                                {
10934                                                setState(1256);
10935                                                tbodyTagOpen();
10936                                                }
10937                                                break;
10938                                        case 30:
10939                                                {
10940                                                setState(1257);
10941                                                theadTagOpen();
10942                                                }
10943                                                break;
10944                                        case 31:
10945                                                {
10946                                                {
10947                                                setState(1258);
10948                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10949                                                setState(1259);
10950                                                match(LEADING_ASTERISK);
10951                                                }
10952                                                }
10953                                                break;
10954                                        case 32:
10955                                                {
10956                                                setState(1260);
10957                                                htmlComment();
10958                                                }
10959                                                break;
10960                                        case 33:
10961                                                {
10962                                                setState(1261);
10963                                                match(CDATA);
10964                                                }
10965                                                break;
10966                                        case 34:
10967                                                {
10968                                                setState(1262);
10969                                                match(NEWLINE);
10970                                                }
10971                                                break;
10972                                        case 35:
10973                                                {
10974                                                setState(1263);
10975                                                text();
10976                                                }
10977                                                break;
10978                                        case 36:
10979                                                {
10980                                                setState(1264);
10981                                                javadocInlineTag();
10982                                                }
10983                                                break;
10984                                        }
10985                                        } 
10986                                }
10987                                setState(1269);
10988                                _errHandler.sync(this);
10989                                _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10990                        }
10991                        setState(1270);
10992                        tfootTagClose();
10993                        }
10994                }
10995                catch (RecognitionException re) {
10996                        _localctx.exception = re;
10997                        _errHandler.reportError(this, re);
10998                        _errHandler.recover(this, re);
10999                }
11000                finally {
11001                        exitRule();
11002                }
11003                return _localctx;
11004        }
11005
11006        public static class TheadTagOpenContext extends ParserRuleContext {
11007                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11008                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11009                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11010                public List<AttributeContext> attribute() {
11011                        return getRuleContexts(AttributeContext.class);
11012                }
11013                public AttributeContext attribute(int i) {
11014                        return getRuleContext(AttributeContext.class,i);
11015                }
11016                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11017                public TerminalNode NEWLINE(int i) {
11018                        return getToken(JavadocParser.NEWLINE, i);
11019                }
11020                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11021                public TerminalNode LEADING_ASTERISK(int i) {
11022                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11023                }
11024                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11025                public TerminalNode WS(int i) {
11026                        return getToken(JavadocParser.WS, i);
11027                }
11028                public TheadTagOpenContext(ParserRuleContext parent, int invokingState) {
11029                        super(parent, invokingState);
11030                }
11031                @Override public int getRuleIndex() { return RULE_theadTagOpen; }
11032                @Override
11033                public void enterRule(ParseTreeListener listener) {
11034                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this);
11035                }
11036                @Override
11037                public void exitRule(ParseTreeListener listener) {
11038                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this);
11039                }
11040                @Override
11041                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11042                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this);
11043                        else return visitor.visitChildren(this);
11044                }
11045        }
11046
11047        public final TheadTagOpenContext theadTagOpen() throws RecognitionException {
11048                TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState());
11049                enterRule(_localctx, 96, RULE_theadTagOpen);
11050                int _la;
11051                try {
11052                        enterOuterAlt(_localctx, 1);
11053                        {
11054                        setState(1272);
11055                        match(OPEN);
11056                        setState(1273);
11057                        match(THEAD_HTML_TAG_NAME);
11058                        setState(1280);
11059                        _errHandler.sync(this);
11060                        _la = _input.LA(1);
11061                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11062                                {
11063                                setState(1278);
11064                                switch (_input.LA(1)) {
11065                                case HTML_TAG_NAME:
11066                                        {
11067                                        setState(1274);
11068                                        attribute();
11069                                        }
11070                                        break;
11071                                case NEWLINE:
11072                                        {
11073                                        setState(1275);
11074                                        match(NEWLINE);
11075                                        }
11076                                        break;
11077                                case LEADING_ASTERISK:
11078                                        {
11079                                        setState(1276);
11080                                        match(LEADING_ASTERISK);
11081                                        }
11082                                        break;
11083                                case WS:
11084                                        {
11085                                        setState(1277);
11086                                        match(WS);
11087                                        }
11088                                        break;
11089                                default:
11090                                        throw new NoViableAltException(this);
11091                                }
11092                                }
11093                                setState(1282);
11094                                _errHandler.sync(this);
11095                                _la = _input.LA(1);
11096                        }
11097                        setState(1283);
11098                        match(CLOSE);
11099                        }
11100                }
11101                catch (RecognitionException re) {
11102                        _localctx.exception = re;
11103                        _errHandler.reportError(this, re);
11104                        _errHandler.recover(this, re);
11105                }
11106                finally {
11107                        exitRule();
11108                }
11109                return _localctx;
11110        }
11111
11112        public static class TheadTagCloseContext extends ParserRuleContext {
11113                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11114                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
11115                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11116                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11117                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11118                public TerminalNode NEWLINE(int i) {
11119                        return getToken(JavadocParser.NEWLINE, i);
11120                }
11121                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11122                public TerminalNode LEADING_ASTERISK(int i) {
11123                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11124                }
11125                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11126                public TerminalNode WS(int i) {
11127                        return getToken(JavadocParser.WS, i);
11128                }
11129                public TheadTagCloseContext(ParserRuleContext parent, int invokingState) {
11130                        super(parent, invokingState);
11131                }
11132                @Override public int getRuleIndex() { return RULE_theadTagClose; }
11133                @Override
11134                public void enterRule(ParseTreeListener listener) {
11135                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this);
11136                }
11137                @Override
11138                public void exitRule(ParseTreeListener listener) {
11139                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this);
11140                }
11141                @Override
11142                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11143                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this);
11144                        else return visitor.visitChildren(this);
11145                }
11146        }
11147
11148        public final TheadTagCloseContext theadTagClose() throws RecognitionException {
11149                TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState());
11150                enterRule(_localctx, 98, RULE_theadTagClose);
11151                int _la;
11152                try {
11153                        enterOuterAlt(_localctx, 1);
11154                        {
11155                        setState(1285);
11156                        match(OPEN);
11157                        setState(1286);
11158                        match(SLASH);
11159                        setState(1287);
11160                        match(THEAD_HTML_TAG_NAME);
11161                        setState(1291);
11162                        _errHandler.sync(this);
11163                        _la = _input.LA(1);
11164                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
11165                                {
11166                                {
11167                                setState(1288);
11168                                _la = _input.LA(1);
11169                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
11170                                _errHandler.recoverInline(this);
11171                                } else {
11172                                        consume();
11173                                }
11174                                }
11175                                }
11176                                setState(1293);
11177                                _errHandler.sync(this);
11178                                _la = _input.LA(1);
11179                        }
11180                        setState(1294);
11181                        match(CLOSE);
11182                        }
11183                }
11184                catch (RecognitionException re) {
11185                        _localctx.exception = re;
11186                        _errHandler.reportError(this, re);
11187                        _errHandler.recover(this, re);
11188                }
11189                finally {
11190                        exitRule();
11191                }
11192                return _localctx;
11193        }
11194
11195        public static class TheadContext extends ParserRuleContext {
11196                public TheadTagOpenContext theadTagOpen() {
11197                        return getRuleContext(TheadTagOpenContext.class,0);
11198                }
11199                public TheadTagCloseContext theadTagClose() {
11200                        return getRuleContext(TheadTagCloseContext.class,0);
11201                }
11202                public List<HtmlTagContext> htmlTag() {
11203                        return getRuleContexts(HtmlTagContext.class);
11204                }
11205                public HtmlTagContext htmlTag(int i) {
11206                        return getRuleContext(HtmlTagContext.class,i);
11207                }
11208                public List<SingletonTagContext> singletonTag() {
11209                        return getRuleContexts(SingletonTagContext.class);
11210                }
11211                public SingletonTagContext singletonTag(int i) {
11212                        return getRuleContext(SingletonTagContext.class,i);
11213                }
11214                public List<ParagraphContext> paragraph() {
11215                        return getRuleContexts(ParagraphContext.class);
11216                }
11217                public ParagraphContext paragraph(int i) {
11218                        return getRuleContext(ParagraphContext.class,i);
11219                }
11220                public List<LiContext> li() {
11221                        return getRuleContexts(LiContext.class);
11222                }
11223                public LiContext li(int i) {
11224                        return getRuleContext(LiContext.class,i);
11225                }
11226                public List<TrContext> tr() {
11227                        return getRuleContexts(TrContext.class);
11228                }
11229                public TrContext tr(int i) {
11230                        return getRuleContext(TrContext.class,i);
11231                }
11232                public List<TdContext> td() {
11233                        return getRuleContexts(TdContext.class);
11234                }
11235                public TdContext td(int i) {
11236                        return getRuleContext(TdContext.class,i);
11237                }
11238                public List<ThContext> th() {
11239                        return getRuleContexts(ThContext.class);
11240                }
11241                public ThContext th(int i) {
11242                        return getRuleContext(ThContext.class,i);
11243                }
11244                public List<BodyContext> body() {
11245                        return getRuleContexts(BodyContext.class);
11246                }
11247                public BodyContext body(int i) {
11248                        return getRuleContext(BodyContext.class,i);
11249                }
11250                public List<ColgroupContext> colgroup() {
11251                        return getRuleContexts(ColgroupContext.class);
11252                }
11253                public ColgroupContext colgroup(int i) {
11254                        return getRuleContext(ColgroupContext.class,i);
11255                }
11256                public List<DdContext> dd() {
11257                        return getRuleContexts(DdContext.class);
11258                }
11259                public DdContext dd(int i) {
11260                        return getRuleContext(DdContext.class,i);
11261                }
11262                public List<DtContext> dt() {
11263                        return getRuleContexts(DtContext.class);
11264                }
11265                public DtContext dt(int i) {
11266                        return getRuleContext(DtContext.class,i);
11267                }
11268                public List<HeadContext> head() {
11269                        return getRuleContexts(HeadContext.class);
11270                }
11271                public HeadContext head(int i) {
11272                        return getRuleContext(HeadContext.class,i);
11273                }
11274                public List<HtmlContext> html() {
11275                        return getRuleContexts(HtmlContext.class);
11276                }
11277                public HtmlContext html(int i) {
11278                        return getRuleContext(HtmlContext.class,i);
11279                }
11280                public List<OptionContext> option() {
11281                        return getRuleContexts(OptionContext.class);
11282                }
11283                public OptionContext option(int i) {
11284                        return getRuleContext(OptionContext.class,i);
11285                }
11286                public List<TbodyContext> tbody() {
11287                        return getRuleContexts(TbodyContext.class);
11288                }
11289                public TbodyContext tbody(int i) {
11290                        return getRuleContext(TbodyContext.class,i);
11291                }
11292                public List<TfootContext> tfoot() {
11293                        return getRuleContexts(TfootContext.class);
11294                }
11295                public TfootContext tfoot(int i) {
11296                        return getRuleContext(TfootContext.class,i);
11297                }
11298                public List<PTagOpenContext> pTagOpen() {
11299                        return getRuleContexts(PTagOpenContext.class);
11300                }
11301                public PTagOpenContext pTagOpen(int i) {
11302                        return getRuleContext(PTagOpenContext.class,i);
11303                }
11304                public List<LiTagOpenContext> liTagOpen() {
11305                        return getRuleContexts(LiTagOpenContext.class);
11306                }
11307                public LiTagOpenContext liTagOpen(int i) {
11308                        return getRuleContext(LiTagOpenContext.class,i);
11309                }
11310                public List<TrTagOpenContext> trTagOpen() {
11311                        return getRuleContexts(TrTagOpenContext.class);
11312                }
11313                public TrTagOpenContext trTagOpen(int i) {
11314                        return getRuleContext(TrTagOpenContext.class,i);
11315                }
11316                public List<TdTagOpenContext> tdTagOpen() {
11317                        return getRuleContexts(TdTagOpenContext.class);
11318                }
11319                public TdTagOpenContext tdTagOpen(int i) {
11320                        return getRuleContext(TdTagOpenContext.class,i);
11321                }
11322                public List<ThTagOpenContext> thTagOpen() {
11323                        return getRuleContexts(ThTagOpenContext.class);
11324                }
11325                public ThTagOpenContext thTagOpen(int i) {
11326                        return getRuleContext(ThTagOpenContext.class,i);
11327                }
11328                public List<BodyTagOpenContext> bodyTagOpen() {
11329                        return getRuleContexts(BodyTagOpenContext.class);
11330                }
11331                public BodyTagOpenContext bodyTagOpen(int i) {
11332                        return getRuleContext(BodyTagOpenContext.class,i);
11333                }
11334                public List<ColgroupTagOpenContext> colgroupTagOpen() {
11335                        return getRuleContexts(ColgroupTagOpenContext.class);
11336                }
11337                public ColgroupTagOpenContext colgroupTagOpen(int i) {
11338                        return getRuleContext(ColgroupTagOpenContext.class,i);
11339                }
11340                public List<DdTagOpenContext> ddTagOpen() {
11341                        return getRuleContexts(DdTagOpenContext.class);
11342                }
11343                public DdTagOpenContext ddTagOpen(int i) {
11344                        return getRuleContext(DdTagOpenContext.class,i);
11345                }
11346                public List<DtTagOpenContext> dtTagOpen() {
11347                        return getRuleContexts(DtTagOpenContext.class);
11348                }
11349                public DtTagOpenContext dtTagOpen(int i) {
11350                        return getRuleContext(DtTagOpenContext.class,i);
11351                }
11352                public List<HeadTagOpenContext> headTagOpen() {
11353                        return getRuleContexts(HeadTagOpenContext.class);
11354                }
11355                public HeadTagOpenContext headTagOpen(int i) {
11356                        return getRuleContext(HeadTagOpenContext.class,i);
11357                }
11358                public List<HtmlTagOpenContext> htmlTagOpen() {
11359                        return getRuleContexts(HtmlTagOpenContext.class);
11360                }
11361                public HtmlTagOpenContext htmlTagOpen(int i) {
11362                        return getRuleContext(HtmlTagOpenContext.class,i);
11363                }
11364                public List<OptionTagOpenContext> optionTagOpen() {
11365                        return getRuleContexts(OptionTagOpenContext.class);
11366                }
11367                public OptionTagOpenContext optionTagOpen(int i) {
11368                        return getRuleContext(OptionTagOpenContext.class,i);
11369                }
11370                public List<TbodyTagOpenContext> tbodyTagOpen() {
11371                        return getRuleContexts(TbodyTagOpenContext.class);
11372                }
11373                public TbodyTagOpenContext tbodyTagOpen(int i) {
11374                        return getRuleContext(TbodyTagOpenContext.class,i);
11375                }
11376                public List<TfootTagOpenContext> tfootTagOpen() {
11377                        return getRuleContexts(TfootTagOpenContext.class);
11378                }
11379                public TfootTagOpenContext tfootTagOpen(int i) {
11380                        return getRuleContext(TfootTagOpenContext.class,i);
11381                }
11382                public List<HtmlCommentContext> htmlComment() {
11383                        return getRuleContexts(HtmlCommentContext.class);
11384                }
11385                public HtmlCommentContext htmlComment(int i) {
11386                        return getRuleContext(HtmlCommentContext.class,i);
11387                }
11388                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
11389                public TerminalNode CDATA(int i) {
11390                        return getToken(JavadocParser.CDATA, i);
11391                }
11392                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11393                public TerminalNode NEWLINE(int i) {
11394                        return getToken(JavadocParser.NEWLINE, i);
11395                }
11396                public List<TextContext> text() {
11397                        return getRuleContexts(TextContext.class);
11398                }
11399                public TextContext text(int i) {
11400                        return getRuleContext(TextContext.class,i);
11401                }
11402                public List<JavadocInlineTagContext> javadocInlineTag() {
11403                        return getRuleContexts(JavadocInlineTagContext.class);
11404                }
11405                public JavadocInlineTagContext javadocInlineTag(int i) {
11406                        return getRuleContext(JavadocInlineTagContext.class,i);
11407                }
11408                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11409                public TerminalNode LEADING_ASTERISK(int i) {
11410                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11411                }
11412                public TheadContext(ParserRuleContext parent, int invokingState) {
11413                        super(parent, invokingState);
11414                }
11415                @Override public int getRuleIndex() { return RULE_thead; }
11416                @Override
11417                public void enterRule(ParseTreeListener listener) {
11418                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this);
11419                }
11420                @Override
11421                public void exitRule(ParseTreeListener listener) {
11422                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this);
11423                }
11424                @Override
11425                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11426                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this);
11427                        else return visitor.visitChildren(this);
11428                }
11429        }
11430
11431        public final TheadContext thead() throws RecognitionException {
11432                TheadContext _localctx = new TheadContext(_ctx, getState());
11433                enterRule(_localctx, 100, RULE_thead);
11434                try {
11435                        int _alt;
11436                        enterOuterAlt(_localctx, 1);
11437                        {
11438                        setState(1296);
11439                        theadTagOpen();
11440                        setState(1336);
11441                        _errHandler.sync(this);
11442                        _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11443                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11444                                if ( _alt==1 ) {
11445                                        {
11446                                        setState(1334);
11447                                        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
11448                                        case 1:
11449                                                {
11450                                                setState(1297);
11451                                                htmlTag();
11452                                                }
11453                                                break;
11454                                        case 2:
11455                                                {
11456                                                setState(1298);
11457                                                singletonTag();
11458                                                }
11459                                                break;
11460                                        case 3:
11461                                                {
11462                                                setState(1299);
11463                                                paragraph();
11464                                                }
11465                                                break;
11466                                        case 4:
11467                                                {
11468                                                setState(1300);
11469                                                li();
11470                                                }
11471                                                break;
11472                                        case 5:
11473                                                {
11474                                                setState(1301);
11475                                                tr();
11476                                                }
11477                                                break;
11478                                        case 6:
11479                                                {
11480                                                setState(1302);
11481                                                td();
11482                                                }
11483                                                break;
11484                                        case 7:
11485                                                {
11486                                                setState(1303);
11487                                                th();
11488                                                }
11489                                                break;
11490                                        case 8:
11491                                                {
11492                                                setState(1304);
11493                                                body();
11494                                                }
11495                                                break;
11496                                        case 9:
11497                                                {
11498                                                setState(1305);
11499                                                colgroup();
11500                                                }
11501                                                break;
11502                                        case 10:
11503                                                {
11504                                                setState(1306);
11505                                                dd();
11506                                                }
11507                                                break;
11508                                        case 11:
11509                                                {
11510                                                setState(1307);
11511                                                dt();
11512                                                }
11513                                                break;
11514                                        case 12:
11515                                                {
11516                                                setState(1308);
11517                                                head();
11518                                                }
11519                                                break;
11520                                        case 13:
11521                                                {
11522                                                setState(1309);
11523                                                html();
11524                                                }
11525                                                break;
11526                                        case 14:
11527                                                {
11528                                                setState(1310);
11529                                                option();
11530                                                }
11531                                                break;
11532                                        case 15:
11533                                                {
11534                                                setState(1311);
11535                                                tbody();
11536                                                }
11537                                                break;
11538                                        case 16:
11539                                                {
11540                                                setState(1312);
11541                                                tfoot();
11542                                                }
11543                                                break;
11544                                        case 17:
11545                                                {
11546                                                setState(1313);
11547                                                pTagOpen();
11548                                                }
11549                                                break;
11550                                        case 18:
11551                                                {
11552                                                setState(1314);
11553                                                liTagOpen();
11554                                                }
11555                                                break;
11556                                        case 19:
11557                                                {
11558                                                setState(1315);
11559                                                trTagOpen();
11560                                                }
11561                                                break;
11562                                        case 20:
11563                                                {
11564                                                setState(1316);
11565                                                tdTagOpen();
11566                                                }
11567                                                break;
11568                                        case 21:
11569                                                {
11570                                                setState(1317);
11571                                                thTagOpen();
11572                                                }
11573                                                break;
11574                                        case 22:
11575                                                {
11576                                                setState(1318);
11577                                                bodyTagOpen();
11578                                                }
11579                                                break;
11580                                        case 23:
11581                                                {
11582                                                setState(1319);
11583                                                colgroupTagOpen();
11584                                                }
11585                                                break;
11586                                        case 24:
11587                                                {
11588                                                setState(1320);
11589                                                ddTagOpen();
11590                                                }
11591                                                break;
11592                                        case 25:
11593                                                {
11594                                                setState(1321);
11595                                                dtTagOpen();
11596                                                }
11597                                                break;
11598                                        case 26:
11599                                                {
11600                                                setState(1322);
11601                                                headTagOpen();
11602                                                }
11603                                                break;
11604                                        case 27:
11605                                                {
11606                                                setState(1323);
11607                                                htmlTagOpen();
11608                                                }
11609                                                break;
11610                                        case 28:
11611                                                {
11612                                                setState(1324);
11613                                                optionTagOpen();
11614                                                }
11615                                                break;
11616                                        case 29:
11617                                                {
11618                                                setState(1325);
11619                                                tbodyTagOpen();
11620                                                }
11621                                                break;
11622                                        case 30:
11623                                                {
11624                                                setState(1326);
11625                                                tfootTagOpen();
11626                                                }
11627                                                break;
11628                                        case 31:
11629                                                {
11630                                                {
11631                                                setState(1327);
11632                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11633                                                setState(1328);
11634                                                match(LEADING_ASTERISK);
11635                                                }
11636                                                }
11637                                                break;
11638                                        case 32:
11639                                                {
11640                                                setState(1329);
11641                                                htmlComment();
11642                                                }
11643                                                break;
11644                                        case 33:
11645                                                {
11646                                                setState(1330);
11647                                                match(CDATA);
11648                                                }
11649                                                break;
11650                                        case 34:
11651                                                {
11652                                                setState(1331);
11653                                                match(NEWLINE);
11654                                                }
11655                                                break;
11656                                        case 35:
11657                                                {
11658                                                setState(1332);
11659                                                text();
11660                                                }
11661                                                break;
11662                                        case 36:
11663                                                {
11664                                                setState(1333);
11665                                                javadocInlineTag();
11666                                                }
11667                                                break;
11668                                        }
11669                                        } 
11670                                }
11671                                setState(1338);
11672                                _errHandler.sync(this);
11673                                _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11674                        }
11675                        setState(1339);
11676                        theadTagClose();
11677                        }
11678                }
11679                catch (RecognitionException re) {
11680                        _localctx.exception = re;
11681                        _errHandler.reportError(this, re);
11682                        _errHandler.recover(this, re);
11683                }
11684                finally {
11685                        exitRule();
11686                }
11687                return _localctx;
11688        }
11689
11690        public static class SingletonElementContext extends ParserRuleContext {
11691                public SingletonTagContext singletonTag() {
11692                        return getRuleContext(SingletonTagContext.class,0);
11693                }
11694                public AreaTagContext areaTag() {
11695                        return getRuleContext(AreaTagContext.class,0);
11696                }
11697                public BaseTagContext baseTag() {
11698                        return getRuleContext(BaseTagContext.class,0);
11699                }
11700                public BasefrontTagContext basefrontTag() {
11701                        return getRuleContext(BasefrontTagContext.class,0);
11702                }
11703                public BrTagContext brTag() {
11704                        return getRuleContext(BrTagContext.class,0);
11705                }
11706                public ColTagContext colTag() {
11707                        return getRuleContext(ColTagContext.class,0);
11708                }
11709                public FrameTagContext frameTag() {
11710                        return getRuleContext(FrameTagContext.class,0);
11711                }
11712                public HrTagContext hrTag() {
11713                        return getRuleContext(HrTagContext.class,0);
11714                }
11715                public ImgTagContext imgTag() {
11716                        return getRuleContext(ImgTagContext.class,0);
11717                }
11718                public InputTagContext inputTag() {
11719                        return getRuleContext(InputTagContext.class,0);
11720                }
11721                public IsindexTagContext isindexTag() {
11722                        return getRuleContext(IsindexTagContext.class,0);
11723                }
11724                public LinkTagContext linkTag() {
11725                        return getRuleContext(LinkTagContext.class,0);
11726                }
11727                public MetaTagContext metaTag() {
11728                        return getRuleContext(MetaTagContext.class,0);
11729                }
11730                public ParamTagContext paramTag() {
11731                        return getRuleContext(ParamTagContext.class,0);
11732                }
11733                public WrongSinletonTagContext wrongSinletonTag() {
11734                        return getRuleContext(WrongSinletonTagContext.class,0);
11735                }
11736                public SingletonElementContext(ParserRuleContext parent, int invokingState) {
11737                        super(parent, invokingState);
11738                }
11739                @Override public int getRuleIndex() { return RULE_singletonElement; }
11740                @Override
11741                public void enterRule(ParseTreeListener listener) {
11742                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this);
11743                }
11744                @Override
11745                public void exitRule(ParseTreeListener listener) {
11746                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this);
11747                }
11748                @Override
11749                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11750                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this);
11751                        else return visitor.visitChildren(this);
11752                }
11753        }
11754
11755        public final SingletonElementContext singletonElement() throws RecognitionException {
11756                SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState());
11757                enterRule(_localctx, 102, RULE_singletonElement);
11758                try {
11759                        setState(1356);
11760                        switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
11761                        case 1:
11762                                enterOuterAlt(_localctx, 1);
11763                                {
11764                                setState(1341);
11765                                singletonTag();
11766                                }
11767                                break;
11768                        case 2:
11769                                enterOuterAlt(_localctx, 2);
11770                                {
11771                                setState(1342);
11772                                areaTag();
11773                                }
11774                                break;
11775                        case 3:
11776                                enterOuterAlt(_localctx, 3);
11777                                {
11778                                setState(1343);
11779                                baseTag();
11780                                }
11781                                break;
11782                        case 4:
11783                                enterOuterAlt(_localctx, 4);
11784                                {
11785                                setState(1344);
11786                                basefrontTag();
11787                                }
11788                                break;
11789                        case 5:
11790                                enterOuterAlt(_localctx, 5);
11791                                {
11792                                setState(1345);
11793                                brTag();
11794                                }
11795                                break;
11796                        case 6:
11797                                enterOuterAlt(_localctx, 6);
11798                                {
11799                                setState(1346);
11800                                colTag();
11801                                }
11802                                break;
11803                        case 7:
11804                                enterOuterAlt(_localctx, 7);
11805                                {
11806                                setState(1347);
11807                                frameTag();
11808                                }
11809                                break;
11810                        case 8:
11811                                enterOuterAlt(_localctx, 8);
11812                                {
11813                                setState(1348);
11814                                hrTag();
11815                                }
11816                                break;
11817                        case 9:
11818                                enterOuterAlt(_localctx, 9);
11819                                {
11820                                setState(1349);
11821                                imgTag();
11822                                }
11823                                break;
11824                        case 10:
11825                                enterOuterAlt(_localctx, 10);
11826                                {
11827                                setState(1350);
11828                                inputTag();
11829                                }
11830                                break;
11831                        case 11:
11832                                enterOuterAlt(_localctx, 11);
11833                                {
11834                                setState(1351);
11835                                isindexTag();
11836                                }
11837                                break;
11838                        case 12:
11839                                enterOuterAlt(_localctx, 12);
11840                                {
11841                                setState(1352);
11842                                linkTag();
11843                                }
11844                                break;
11845                        case 13:
11846                                enterOuterAlt(_localctx, 13);
11847                                {
11848                                setState(1353);
11849                                metaTag();
11850                                }
11851                                break;
11852                        case 14:
11853                                enterOuterAlt(_localctx, 14);
11854                                {
11855                                setState(1354);
11856                                paramTag();
11857                                }
11858                                break;
11859                        case 15:
11860                                enterOuterAlt(_localctx, 15);
11861                                {
11862                                setState(1355);
11863                                wrongSinletonTag();
11864                                }
11865                                break;
11866                        }
11867                }
11868                catch (RecognitionException re) {
11869                        _localctx.exception = re;
11870                        _errHandler.reportError(this, re);
11871                        _errHandler.recover(this, re);
11872                }
11873                finally {
11874                        exitRule();
11875                }
11876                return _localctx;
11877        }
11878
11879        public static class SingletonTagContext extends ParserRuleContext {
11880                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11881                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11882                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
11883                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
11884                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
11885                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
11886                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
11887                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
11888                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
11889                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
11890                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
11891                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
11892                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
11893                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
11894                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
11895                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
11896                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
11897                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11898                public List<AttributeContext> attribute() {
11899                        return getRuleContexts(AttributeContext.class);
11900                }
11901                public AttributeContext attribute(int i) {
11902                        return getRuleContext(AttributeContext.class,i);
11903                }
11904                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11905                public TerminalNode NEWLINE(int i) {
11906                        return getToken(JavadocParser.NEWLINE, i);
11907                }
11908                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11909                public TerminalNode LEADING_ASTERISK(int i) {
11910                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11911                }
11912                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11913                public TerminalNode WS(int i) {
11914                        return getToken(JavadocParser.WS, i);
11915                }
11916                public SingletonTagContext(ParserRuleContext parent, int invokingState) {
11917                        super(parent, invokingState);
11918                }
11919                @Override public int getRuleIndex() { return RULE_singletonTag; }
11920                @Override
11921                public void enterRule(ParseTreeListener listener) {
11922                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this);
11923                }
11924                @Override
11925                public void exitRule(ParseTreeListener listener) {
11926                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this);
11927                }
11928                @Override
11929                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11930                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this);
11931                        else return visitor.visitChildren(this);
11932                }
11933        }
11934
11935        public final SingletonTagContext singletonTag() throws RecognitionException {
11936                SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState());
11937                enterRule(_localctx, 104, RULE_singletonTag);
11938                int _la;
11939                try {
11940                        enterOuterAlt(_localctx, 1);
11941                        {
11942                        setState(1358);
11943                        match(OPEN);
11944                        setState(1359);
11945                        _la = _input.LA(1);
11946                        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)) ) {
11947                        _errHandler.recoverInline(this);
11948                        } else {
11949                                consume();
11950                        }
11951                        setState(1366);
11952                        _errHandler.sync(this);
11953                        _la = _input.LA(1);
11954                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11955                                {
11956                                setState(1364);
11957                                switch (_input.LA(1)) {
11958                                case HTML_TAG_NAME:
11959                                        {
11960                                        setState(1360);
11961                                        attribute();
11962                                        }
11963                                        break;
11964                                case NEWLINE:
11965                                        {
11966                                        setState(1361);
11967                                        match(NEWLINE);
11968                                        }
11969                                        break;
11970                                case LEADING_ASTERISK:
11971                                        {
11972                                        setState(1362);
11973                                        match(LEADING_ASTERISK);
11974                                        }
11975                                        break;
11976                                case WS:
11977                                        {
11978                                        setState(1363);
11979                                        match(WS);
11980                                        }
11981                                        break;
11982                                default:
11983                                        throw new NoViableAltException(this);
11984                                }
11985                                }
11986                                setState(1368);
11987                                _errHandler.sync(this);
11988                                _la = _input.LA(1);
11989                        }
11990                        setState(1369);
11991                        match(SLASH_CLOSE);
11992                        }
11993                }
11994                catch (RecognitionException re) {
11995                        _localctx.exception = re;
11996                        _errHandler.reportError(this, re);
11997                        _errHandler.recover(this, re);
11998                }
11999                finally {
12000                        exitRule();
12001                }
12002                return _localctx;
12003        }
12004
12005        public static class AreaTagContext extends ParserRuleContext {
12006                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12007                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
12008                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12009                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12010                public List<AttributeContext> attribute() {
12011                        return getRuleContexts(AttributeContext.class);
12012                }
12013                public AttributeContext attribute(int i) {
12014                        return getRuleContext(AttributeContext.class,i);
12015                }
12016                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12017                public TerminalNode NEWLINE(int i) {
12018                        return getToken(JavadocParser.NEWLINE, i);
12019                }
12020                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12021                public TerminalNode LEADING_ASTERISK(int i) {
12022                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12023                }
12024                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12025                public TerminalNode WS(int i) {
12026                        return getToken(JavadocParser.WS, i);
12027                }
12028                public AreaTagContext(ParserRuleContext parent, int invokingState) {
12029                        super(parent, invokingState);
12030                }
12031                @Override public int getRuleIndex() { return RULE_areaTag; }
12032                @Override
12033                public void enterRule(ParseTreeListener listener) {
12034                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this);
12035                }
12036                @Override
12037                public void exitRule(ParseTreeListener listener) {
12038                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this);
12039                }
12040                @Override
12041                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12042                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this);
12043                        else return visitor.visitChildren(this);
12044                }
12045        }
12046
12047        public final AreaTagContext areaTag() throws RecognitionException {
12048                AreaTagContext _localctx = new AreaTagContext(_ctx, getState());
12049                enterRule(_localctx, 106, RULE_areaTag);
12050                int _la;
12051                try {
12052                        enterOuterAlt(_localctx, 1);
12053                        {
12054                        setState(1371);
12055                        match(OPEN);
12056                        setState(1372);
12057                        match(AREA_HTML_TAG_NAME);
12058                        setState(1379);
12059                        _errHandler.sync(this);
12060                        _la = _input.LA(1);
12061                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12062                                {
12063                                setState(1377);
12064                                switch (_input.LA(1)) {
12065                                case HTML_TAG_NAME:
12066                                        {
12067                                        setState(1373);
12068                                        attribute();
12069                                        }
12070                                        break;
12071                                case NEWLINE:
12072                                        {
12073                                        setState(1374);
12074                                        match(NEWLINE);
12075                                        }
12076                                        break;
12077                                case LEADING_ASTERISK:
12078                                        {
12079                                        setState(1375);
12080                                        match(LEADING_ASTERISK);
12081                                        }
12082                                        break;
12083                                case WS:
12084                                        {
12085                                        setState(1376);
12086                                        match(WS);
12087                                        }
12088                                        break;
12089                                default:
12090                                        throw new NoViableAltException(this);
12091                                }
12092                                }
12093                                setState(1381);
12094                                _errHandler.sync(this);
12095                                _la = _input.LA(1);
12096                        }
12097                        setState(1382);
12098                        _la = _input.LA(1);
12099                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12100                        _errHandler.recoverInline(this);
12101                        } else {
12102                                consume();
12103                        }
12104                        }
12105                }
12106                catch (RecognitionException re) {
12107                        _localctx.exception = re;
12108                        _errHandler.reportError(this, re);
12109                        _errHandler.recover(this, re);
12110                }
12111                finally {
12112                        exitRule();
12113                }
12114                return _localctx;
12115        }
12116
12117        public static class BaseTagContext extends ParserRuleContext {
12118                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12119                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
12120                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12121                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12122                public List<AttributeContext> attribute() {
12123                        return getRuleContexts(AttributeContext.class);
12124                }
12125                public AttributeContext attribute(int i) {
12126                        return getRuleContext(AttributeContext.class,i);
12127                }
12128                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12129                public TerminalNode NEWLINE(int i) {
12130                        return getToken(JavadocParser.NEWLINE, i);
12131                }
12132                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12133                public TerminalNode LEADING_ASTERISK(int i) {
12134                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12135                }
12136                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12137                public TerminalNode WS(int i) {
12138                        return getToken(JavadocParser.WS, i);
12139                }
12140                public BaseTagContext(ParserRuleContext parent, int invokingState) {
12141                        super(parent, invokingState);
12142                }
12143                @Override public int getRuleIndex() { return RULE_baseTag; }
12144                @Override
12145                public void enterRule(ParseTreeListener listener) {
12146                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this);
12147                }
12148                @Override
12149                public void exitRule(ParseTreeListener listener) {
12150                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this);
12151                }
12152                @Override
12153                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12154                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this);
12155                        else return visitor.visitChildren(this);
12156                }
12157        }
12158
12159        public final BaseTagContext baseTag() throws RecognitionException {
12160                BaseTagContext _localctx = new BaseTagContext(_ctx, getState());
12161                enterRule(_localctx, 108, RULE_baseTag);
12162                int _la;
12163                try {
12164                        enterOuterAlt(_localctx, 1);
12165                        {
12166                        setState(1384);
12167                        match(OPEN);
12168                        setState(1385);
12169                        match(BASE_HTML_TAG_NAME);
12170                        setState(1392);
12171                        _errHandler.sync(this);
12172                        _la = _input.LA(1);
12173                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12174                                {
12175                                setState(1390);
12176                                switch (_input.LA(1)) {
12177                                case HTML_TAG_NAME:
12178                                        {
12179                                        setState(1386);
12180                                        attribute();
12181                                        }
12182                                        break;
12183                                case NEWLINE:
12184                                        {
12185                                        setState(1387);
12186                                        match(NEWLINE);
12187                                        }
12188                                        break;
12189                                case LEADING_ASTERISK:
12190                                        {
12191                                        setState(1388);
12192                                        match(LEADING_ASTERISK);
12193                                        }
12194                                        break;
12195                                case WS:
12196                                        {
12197                                        setState(1389);
12198                                        match(WS);
12199                                        }
12200                                        break;
12201                                default:
12202                                        throw new NoViableAltException(this);
12203                                }
12204                                }
12205                                setState(1394);
12206                                _errHandler.sync(this);
12207                                _la = _input.LA(1);
12208                        }
12209                        setState(1395);
12210                        _la = _input.LA(1);
12211                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12212                        _errHandler.recoverInline(this);
12213                        } else {
12214                                consume();
12215                        }
12216                        }
12217                }
12218                catch (RecognitionException re) {
12219                        _localctx.exception = re;
12220                        _errHandler.reportError(this, re);
12221                        _errHandler.recover(this, re);
12222                }
12223                finally {
12224                        exitRule();
12225                }
12226                return _localctx;
12227        }
12228
12229        public static class BasefrontTagContext extends ParserRuleContext {
12230                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12231                public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); }
12232                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12233                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12234                public List<AttributeContext> attribute() {
12235                        return getRuleContexts(AttributeContext.class);
12236                }
12237                public AttributeContext attribute(int i) {
12238                        return getRuleContext(AttributeContext.class,i);
12239                }
12240                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12241                public TerminalNode NEWLINE(int i) {
12242                        return getToken(JavadocParser.NEWLINE, i);
12243                }
12244                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12245                public TerminalNode LEADING_ASTERISK(int i) {
12246                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12247                }
12248                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12249                public TerminalNode WS(int i) {
12250                        return getToken(JavadocParser.WS, i);
12251                }
12252                public BasefrontTagContext(ParserRuleContext parent, int invokingState) {
12253                        super(parent, invokingState);
12254                }
12255                @Override public int getRuleIndex() { return RULE_basefrontTag; }
12256                @Override
12257                public void enterRule(ParseTreeListener listener) {
12258                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefrontTag(this);
12259                }
12260                @Override
12261                public void exitRule(ParseTreeListener listener) {
12262                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefrontTag(this);
12263                }
12264                @Override
12265                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12266                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefrontTag(this);
12267                        else return visitor.visitChildren(this);
12268                }
12269        }
12270
12271        public final BasefrontTagContext basefrontTag() throws RecognitionException {
12272                BasefrontTagContext _localctx = new BasefrontTagContext(_ctx, getState());
12273                enterRule(_localctx, 110, RULE_basefrontTag);
12274                int _la;
12275                try {
12276                        enterOuterAlt(_localctx, 1);
12277                        {
12278                        setState(1397);
12279                        match(OPEN);
12280                        setState(1398);
12281                        match(BASEFRONT_HTML_TAG_NAME);
12282                        setState(1405);
12283                        _errHandler.sync(this);
12284                        _la = _input.LA(1);
12285                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12286                                {
12287                                setState(1403);
12288                                switch (_input.LA(1)) {
12289                                case HTML_TAG_NAME:
12290                                        {
12291                                        setState(1399);
12292                                        attribute();
12293                                        }
12294                                        break;
12295                                case NEWLINE:
12296                                        {
12297                                        setState(1400);
12298                                        match(NEWLINE);
12299                                        }
12300                                        break;
12301                                case LEADING_ASTERISK:
12302                                        {
12303                                        setState(1401);
12304                                        match(LEADING_ASTERISK);
12305                                        }
12306                                        break;
12307                                case WS:
12308                                        {
12309                                        setState(1402);
12310                                        match(WS);
12311                                        }
12312                                        break;
12313                                default:
12314                                        throw new NoViableAltException(this);
12315                                }
12316                                }
12317                                setState(1407);
12318                                _errHandler.sync(this);
12319                                _la = _input.LA(1);
12320                        }
12321                        setState(1408);
12322                        _la = _input.LA(1);
12323                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12324                        _errHandler.recoverInline(this);
12325                        } else {
12326                                consume();
12327                        }
12328                        }
12329                }
12330                catch (RecognitionException re) {
12331                        _localctx.exception = re;
12332                        _errHandler.reportError(this, re);
12333                        _errHandler.recover(this, re);
12334                }
12335                finally {
12336                        exitRule();
12337                }
12338                return _localctx;
12339        }
12340
12341        public static class BrTagContext extends ParserRuleContext {
12342                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12343                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
12344                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12345                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12346                public List<AttributeContext> attribute() {
12347                        return getRuleContexts(AttributeContext.class);
12348                }
12349                public AttributeContext attribute(int i) {
12350                        return getRuleContext(AttributeContext.class,i);
12351                }
12352                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12353                public TerminalNode NEWLINE(int i) {
12354                        return getToken(JavadocParser.NEWLINE, i);
12355                }
12356                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12357                public TerminalNode LEADING_ASTERISK(int i) {
12358                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12359                }
12360                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12361                public TerminalNode WS(int i) {
12362                        return getToken(JavadocParser.WS, i);
12363                }
12364                public BrTagContext(ParserRuleContext parent, int invokingState) {
12365                        super(parent, invokingState);
12366                }
12367                @Override public int getRuleIndex() { return RULE_brTag; }
12368                @Override
12369                public void enterRule(ParseTreeListener listener) {
12370                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this);
12371                }
12372                @Override
12373                public void exitRule(ParseTreeListener listener) {
12374                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this);
12375                }
12376                @Override
12377                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12378                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this);
12379                        else return visitor.visitChildren(this);
12380                }
12381        }
12382
12383        public final BrTagContext brTag() throws RecognitionException {
12384                BrTagContext _localctx = new BrTagContext(_ctx, getState());
12385                enterRule(_localctx, 112, RULE_brTag);
12386                int _la;
12387                try {
12388                        enterOuterAlt(_localctx, 1);
12389                        {
12390                        setState(1410);
12391                        match(OPEN);
12392                        setState(1411);
12393                        match(BR_HTML_TAG_NAME);
12394                        setState(1418);
12395                        _errHandler.sync(this);
12396                        _la = _input.LA(1);
12397                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12398                                {
12399                                setState(1416);
12400                                switch (_input.LA(1)) {
12401                                case HTML_TAG_NAME:
12402                                        {
12403                                        setState(1412);
12404                                        attribute();
12405                                        }
12406                                        break;
12407                                case NEWLINE:
12408                                        {
12409                                        setState(1413);
12410                                        match(NEWLINE);
12411                                        }
12412                                        break;
12413                                case LEADING_ASTERISK:
12414                                        {
12415                                        setState(1414);
12416                                        match(LEADING_ASTERISK);
12417                                        }
12418                                        break;
12419                                case WS:
12420                                        {
12421                                        setState(1415);
12422                                        match(WS);
12423                                        }
12424                                        break;
12425                                default:
12426                                        throw new NoViableAltException(this);
12427                                }
12428                                }
12429                                setState(1420);
12430                                _errHandler.sync(this);
12431                                _la = _input.LA(1);
12432                        }
12433                        setState(1421);
12434                        _la = _input.LA(1);
12435                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12436                        _errHandler.recoverInline(this);
12437                        } else {
12438                                consume();
12439                        }
12440                        }
12441                }
12442                catch (RecognitionException re) {
12443                        _localctx.exception = re;
12444                        _errHandler.reportError(this, re);
12445                        _errHandler.recover(this, re);
12446                }
12447                finally {
12448                        exitRule();
12449                }
12450                return _localctx;
12451        }
12452
12453        public static class ColTagContext extends ParserRuleContext {
12454                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12455                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
12456                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12457                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12458                public List<AttributeContext> attribute() {
12459                        return getRuleContexts(AttributeContext.class);
12460                }
12461                public AttributeContext attribute(int i) {
12462                        return getRuleContext(AttributeContext.class,i);
12463                }
12464                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12465                public TerminalNode NEWLINE(int i) {
12466                        return getToken(JavadocParser.NEWLINE, i);
12467                }
12468                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12469                public TerminalNode LEADING_ASTERISK(int i) {
12470                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12471                }
12472                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12473                public TerminalNode WS(int i) {
12474                        return getToken(JavadocParser.WS, i);
12475                }
12476                public ColTagContext(ParserRuleContext parent, int invokingState) {
12477                        super(parent, invokingState);
12478                }
12479                @Override public int getRuleIndex() { return RULE_colTag; }
12480                @Override
12481                public void enterRule(ParseTreeListener listener) {
12482                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this);
12483                }
12484                @Override
12485                public void exitRule(ParseTreeListener listener) {
12486                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this);
12487                }
12488                @Override
12489                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12490                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this);
12491                        else return visitor.visitChildren(this);
12492                }
12493        }
12494
12495        public final ColTagContext colTag() throws RecognitionException {
12496                ColTagContext _localctx = new ColTagContext(_ctx, getState());
12497                enterRule(_localctx, 114, RULE_colTag);
12498                int _la;
12499                try {
12500                        enterOuterAlt(_localctx, 1);
12501                        {
12502                        setState(1423);
12503                        match(OPEN);
12504                        setState(1424);
12505                        match(COL_HTML_TAG_NAME);
12506                        setState(1431);
12507                        _errHandler.sync(this);
12508                        _la = _input.LA(1);
12509                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12510                                {
12511                                setState(1429);
12512                                switch (_input.LA(1)) {
12513                                case HTML_TAG_NAME:
12514                                        {
12515                                        setState(1425);
12516                                        attribute();
12517                                        }
12518                                        break;
12519                                case NEWLINE:
12520                                        {
12521                                        setState(1426);
12522                                        match(NEWLINE);
12523                                        }
12524                                        break;
12525                                case LEADING_ASTERISK:
12526                                        {
12527                                        setState(1427);
12528                                        match(LEADING_ASTERISK);
12529                                        }
12530                                        break;
12531                                case WS:
12532                                        {
12533                                        setState(1428);
12534                                        match(WS);
12535                                        }
12536                                        break;
12537                                default:
12538                                        throw new NoViableAltException(this);
12539                                }
12540                                }
12541                                setState(1433);
12542                                _errHandler.sync(this);
12543                                _la = _input.LA(1);
12544                        }
12545                        setState(1434);
12546                        _la = _input.LA(1);
12547                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12548                        _errHandler.recoverInline(this);
12549                        } else {
12550                                consume();
12551                        }
12552                        }
12553                }
12554                catch (RecognitionException re) {
12555                        _localctx.exception = re;
12556                        _errHandler.reportError(this, re);
12557                        _errHandler.recover(this, re);
12558                }
12559                finally {
12560                        exitRule();
12561                }
12562                return _localctx;
12563        }
12564
12565        public static class FrameTagContext extends ParserRuleContext {
12566                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12567                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
12568                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12569                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12570                public List<AttributeContext> attribute() {
12571                        return getRuleContexts(AttributeContext.class);
12572                }
12573                public AttributeContext attribute(int i) {
12574                        return getRuleContext(AttributeContext.class,i);
12575                }
12576                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12577                public TerminalNode NEWLINE(int i) {
12578                        return getToken(JavadocParser.NEWLINE, i);
12579                }
12580                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12581                public TerminalNode LEADING_ASTERISK(int i) {
12582                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12583                }
12584                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12585                public TerminalNode WS(int i) {
12586                        return getToken(JavadocParser.WS, i);
12587                }
12588                public FrameTagContext(ParserRuleContext parent, int invokingState) {
12589                        super(parent, invokingState);
12590                }
12591                @Override public int getRuleIndex() { return RULE_frameTag; }
12592                @Override
12593                public void enterRule(ParseTreeListener listener) {
12594                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this);
12595                }
12596                @Override
12597                public void exitRule(ParseTreeListener listener) {
12598                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this);
12599                }
12600                @Override
12601                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12602                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this);
12603                        else return visitor.visitChildren(this);
12604                }
12605        }
12606
12607        public final FrameTagContext frameTag() throws RecognitionException {
12608                FrameTagContext _localctx = new FrameTagContext(_ctx, getState());
12609                enterRule(_localctx, 116, RULE_frameTag);
12610                int _la;
12611                try {
12612                        enterOuterAlt(_localctx, 1);
12613                        {
12614                        setState(1436);
12615                        match(OPEN);
12616                        setState(1437);
12617                        match(FRAME_HTML_TAG_NAME);
12618                        setState(1444);
12619                        _errHandler.sync(this);
12620                        _la = _input.LA(1);
12621                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12622                                {
12623                                setState(1442);
12624                                switch (_input.LA(1)) {
12625                                case HTML_TAG_NAME:
12626                                        {
12627                                        setState(1438);
12628                                        attribute();
12629                                        }
12630                                        break;
12631                                case NEWLINE:
12632                                        {
12633                                        setState(1439);
12634                                        match(NEWLINE);
12635                                        }
12636                                        break;
12637                                case LEADING_ASTERISK:
12638                                        {
12639                                        setState(1440);
12640                                        match(LEADING_ASTERISK);
12641                                        }
12642                                        break;
12643                                case WS:
12644                                        {
12645                                        setState(1441);
12646                                        match(WS);
12647                                        }
12648                                        break;
12649                                default:
12650                                        throw new NoViableAltException(this);
12651                                }
12652                                }
12653                                setState(1446);
12654                                _errHandler.sync(this);
12655                                _la = _input.LA(1);
12656                        }
12657                        setState(1447);
12658                        _la = _input.LA(1);
12659                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12660                        _errHandler.recoverInline(this);
12661                        } else {
12662                                consume();
12663                        }
12664                        }
12665                }
12666                catch (RecognitionException re) {
12667                        _localctx.exception = re;
12668                        _errHandler.reportError(this, re);
12669                        _errHandler.recover(this, re);
12670                }
12671                finally {
12672                        exitRule();
12673                }
12674                return _localctx;
12675        }
12676
12677        public static class HrTagContext extends ParserRuleContext {
12678                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12679                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
12680                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12681                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12682                public List<AttributeContext> attribute() {
12683                        return getRuleContexts(AttributeContext.class);
12684                }
12685                public AttributeContext attribute(int i) {
12686                        return getRuleContext(AttributeContext.class,i);
12687                }
12688                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12689                public TerminalNode NEWLINE(int i) {
12690                        return getToken(JavadocParser.NEWLINE, i);
12691                }
12692                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12693                public TerminalNode LEADING_ASTERISK(int i) {
12694                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12695                }
12696                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12697                public TerminalNode WS(int i) {
12698                        return getToken(JavadocParser.WS, i);
12699                }
12700                public HrTagContext(ParserRuleContext parent, int invokingState) {
12701                        super(parent, invokingState);
12702                }
12703                @Override public int getRuleIndex() { return RULE_hrTag; }
12704                @Override
12705                public void enterRule(ParseTreeListener listener) {
12706                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this);
12707                }
12708                @Override
12709                public void exitRule(ParseTreeListener listener) {
12710                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this);
12711                }
12712                @Override
12713                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12714                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this);
12715                        else return visitor.visitChildren(this);
12716                }
12717        }
12718
12719        public final HrTagContext hrTag() throws RecognitionException {
12720                HrTagContext _localctx = new HrTagContext(_ctx, getState());
12721                enterRule(_localctx, 118, RULE_hrTag);
12722                int _la;
12723                try {
12724                        enterOuterAlt(_localctx, 1);
12725                        {
12726                        setState(1449);
12727                        match(OPEN);
12728                        setState(1450);
12729                        match(HR_HTML_TAG_NAME);
12730                        setState(1457);
12731                        _errHandler.sync(this);
12732                        _la = _input.LA(1);
12733                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12734                                {
12735                                setState(1455);
12736                                switch (_input.LA(1)) {
12737                                case HTML_TAG_NAME:
12738                                        {
12739                                        setState(1451);
12740                                        attribute();
12741                                        }
12742                                        break;
12743                                case NEWLINE:
12744                                        {
12745                                        setState(1452);
12746                                        match(NEWLINE);
12747                                        }
12748                                        break;
12749                                case LEADING_ASTERISK:
12750                                        {
12751                                        setState(1453);
12752                                        match(LEADING_ASTERISK);
12753                                        }
12754                                        break;
12755                                case WS:
12756                                        {
12757                                        setState(1454);
12758                                        match(WS);
12759                                        }
12760                                        break;
12761                                default:
12762                                        throw new NoViableAltException(this);
12763                                }
12764                                }
12765                                setState(1459);
12766                                _errHandler.sync(this);
12767                                _la = _input.LA(1);
12768                        }
12769                        setState(1460);
12770                        _la = _input.LA(1);
12771                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12772                        _errHandler.recoverInline(this);
12773                        } else {
12774                                consume();
12775                        }
12776                        }
12777                }
12778                catch (RecognitionException re) {
12779                        _localctx.exception = re;
12780                        _errHandler.reportError(this, re);
12781                        _errHandler.recover(this, re);
12782                }
12783                finally {
12784                        exitRule();
12785                }
12786                return _localctx;
12787        }
12788
12789        public static class ImgTagContext extends ParserRuleContext {
12790                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12791                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
12792                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12793                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12794                public List<AttributeContext> attribute() {
12795                        return getRuleContexts(AttributeContext.class);
12796                }
12797                public AttributeContext attribute(int i) {
12798                        return getRuleContext(AttributeContext.class,i);
12799                }
12800                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12801                public TerminalNode NEWLINE(int i) {
12802                        return getToken(JavadocParser.NEWLINE, i);
12803                }
12804                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12805                public TerminalNode LEADING_ASTERISK(int i) {
12806                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12807                }
12808                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12809                public TerminalNode WS(int i) {
12810                        return getToken(JavadocParser.WS, i);
12811                }
12812                public ImgTagContext(ParserRuleContext parent, int invokingState) {
12813                        super(parent, invokingState);
12814                }
12815                @Override public int getRuleIndex() { return RULE_imgTag; }
12816                @Override
12817                public void enterRule(ParseTreeListener listener) {
12818                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this);
12819                }
12820                @Override
12821                public void exitRule(ParseTreeListener listener) {
12822                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this);
12823                }
12824                @Override
12825                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12826                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this);
12827                        else return visitor.visitChildren(this);
12828                }
12829        }
12830
12831        public final ImgTagContext imgTag() throws RecognitionException {
12832                ImgTagContext _localctx = new ImgTagContext(_ctx, getState());
12833                enterRule(_localctx, 120, RULE_imgTag);
12834                int _la;
12835                try {
12836                        enterOuterAlt(_localctx, 1);
12837                        {
12838                        setState(1462);
12839                        match(OPEN);
12840                        setState(1463);
12841                        match(IMG_HTML_TAG_NAME);
12842                        setState(1470);
12843                        _errHandler.sync(this);
12844                        _la = _input.LA(1);
12845                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12846                                {
12847                                setState(1468);
12848                                switch (_input.LA(1)) {
12849                                case HTML_TAG_NAME:
12850                                        {
12851                                        setState(1464);
12852                                        attribute();
12853                                        }
12854                                        break;
12855                                case NEWLINE:
12856                                        {
12857                                        setState(1465);
12858                                        match(NEWLINE);
12859                                        }
12860                                        break;
12861                                case LEADING_ASTERISK:
12862                                        {
12863                                        setState(1466);
12864                                        match(LEADING_ASTERISK);
12865                                        }
12866                                        break;
12867                                case WS:
12868                                        {
12869                                        setState(1467);
12870                                        match(WS);
12871                                        }
12872                                        break;
12873                                default:
12874                                        throw new NoViableAltException(this);
12875                                }
12876                                }
12877                                setState(1472);
12878                                _errHandler.sync(this);
12879                                _la = _input.LA(1);
12880                        }
12881                        setState(1473);
12882                        _la = _input.LA(1);
12883                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12884                        _errHandler.recoverInline(this);
12885                        } else {
12886                                consume();
12887                        }
12888                        }
12889                }
12890                catch (RecognitionException re) {
12891                        _localctx.exception = re;
12892                        _errHandler.reportError(this, re);
12893                        _errHandler.recover(this, re);
12894                }
12895                finally {
12896                        exitRule();
12897                }
12898                return _localctx;
12899        }
12900
12901        public static class InputTagContext extends ParserRuleContext {
12902                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12903                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
12904                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12905                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12906                public List<AttributeContext> attribute() {
12907                        return getRuleContexts(AttributeContext.class);
12908                }
12909                public AttributeContext attribute(int i) {
12910                        return getRuleContext(AttributeContext.class,i);
12911                }
12912                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12913                public TerminalNode NEWLINE(int i) {
12914                        return getToken(JavadocParser.NEWLINE, i);
12915                }
12916                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12917                public TerminalNode LEADING_ASTERISK(int i) {
12918                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12919                }
12920                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12921                public TerminalNode WS(int i) {
12922                        return getToken(JavadocParser.WS, i);
12923                }
12924                public InputTagContext(ParserRuleContext parent, int invokingState) {
12925                        super(parent, invokingState);
12926                }
12927                @Override public int getRuleIndex() { return RULE_inputTag; }
12928                @Override
12929                public void enterRule(ParseTreeListener listener) {
12930                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this);
12931                }
12932                @Override
12933                public void exitRule(ParseTreeListener listener) {
12934                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this);
12935                }
12936                @Override
12937                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12938                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this);
12939                        else return visitor.visitChildren(this);
12940                }
12941        }
12942
12943        public final InputTagContext inputTag() throws RecognitionException {
12944                InputTagContext _localctx = new InputTagContext(_ctx, getState());
12945                enterRule(_localctx, 122, RULE_inputTag);
12946                int _la;
12947                try {
12948                        enterOuterAlt(_localctx, 1);
12949                        {
12950                        setState(1475);
12951                        match(OPEN);
12952                        setState(1476);
12953                        match(INPUT_HTML_TAG_NAME);
12954                        setState(1483);
12955                        _errHandler.sync(this);
12956                        _la = _input.LA(1);
12957                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12958                                {
12959                                setState(1481);
12960                                switch (_input.LA(1)) {
12961                                case HTML_TAG_NAME:
12962                                        {
12963                                        setState(1477);
12964                                        attribute();
12965                                        }
12966                                        break;
12967                                case NEWLINE:
12968                                        {
12969                                        setState(1478);
12970                                        match(NEWLINE);
12971                                        }
12972                                        break;
12973                                case LEADING_ASTERISK:
12974                                        {
12975                                        setState(1479);
12976                                        match(LEADING_ASTERISK);
12977                                        }
12978                                        break;
12979                                case WS:
12980                                        {
12981                                        setState(1480);
12982                                        match(WS);
12983                                        }
12984                                        break;
12985                                default:
12986                                        throw new NoViableAltException(this);
12987                                }
12988                                }
12989                                setState(1485);
12990                                _errHandler.sync(this);
12991                                _la = _input.LA(1);
12992                        }
12993                        setState(1486);
12994                        _la = _input.LA(1);
12995                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12996                        _errHandler.recoverInline(this);
12997                        } else {
12998                                consume();
12999                        }
13000                        }
13001                }
13002                catch (RecognitionException re) {
13003                        _localctx.exception = re;
13004                        _errHandler.reportError(this, re);
13005                        _errHandler.recover(this, re);
13006                }
13007                finally {
13008                        exitRule();
13009                }
13010                return _localctx;
13011        }
13012
13013        public static class IsindexTagContext extends ParserRuleContext {
13014                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13015                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13016                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13017                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13018                public List<AttributeContext> attribute() {
13019                        return getRuleContexts(AttributeContext.class);
13020                }
13021                public AttributeContext attribute(int i) {
13022                        return getRuleContext(AttributeContext.class,i);
13023                }
13024                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13025                public TerminalNode NEWLINE(int i) {
13026                        return getToken(JavadocParser.NEWLINE, i);
13027                }
13028                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13029                public TerminalNode LEADING_ASTERISK(int i) {
13030                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13031                }
13032                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13033                public TerminalNode WS(int i) {
13034                        return getToken(JavadocParser.WS, i);
13035                }
13036                public IsindexTagContext(ParserRuleContext parent, int invokingState) {
13037                        super(parent, invokingState);
13038                }
13039                @Override public int getRuleIndex() { return RULE_isindexTag; }
13040                @Override
13041                public void enterRule(ParseTreeListener listener) {
13042                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this);
13043                }
13044                @Override
13045                public void exitRule(ParseTreeListener listener) {
13046                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this);
13047                }
13048                @Override
13049                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13050                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this);
13051                        else return visitor.visitChildren(this);
13052                }
13053        }
13054
13055        public final IsindexTagContext isindexTag() throws RecognitionException {
13056                IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState());
13057                enterRule(_localctx, 124, RULE_isindexTag);
13058                int _la;
13059                try {
13060                        enterOuterAlt(_localctx, 1);
13061                        {
13062                        setState(1488);
13063                        match(OPEN);
13064                        setState(1489);
13065                        match(ISINDEX_HTML_TAG_NAME);
13066                        setState(1496);
13067                        _errHandler.sync(this);
13068                        _la = _input.LA(1);
13069                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13070                                {
13071                                setState(1494);
13072                                switch (_input.LA(1)) {
13073                                case HTML_TAG_NAME:
13074                                        {
13075                                        setState(1490);
13076                                        attribute();
13077                                        }
13078                                        break;
13079                                case NEWLINE:
13080                                        {
13081                                        setState(1491);
13082                                        match(NEWLINE);
13083                                        }
13084                                        break;
13085                                case LEADING_ASTERISK:
13086                                        {
13087                                        setState(1492);
13088                                        match(LEADING_ASTERISK);
13089                                        }
13090                                        break;
13091                                case WS:
13092                                        {
13093                                        setState(1493);
13094                                        match(WS);
13095                                        }
13096                                        break;
13097                                default:
13098                                        throw new NoViableAltException(this);
13099                                }
13100                                }
13101                                setState(1498);
13102                                _errHandler.sync(this);
13103                                _la = _input.LA(1);
13104                        }
13105                        setState(1499);
13106                        _la = _input.LA(1);
13107                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13108                        _errHandler.recoverInline(this);
13109                        } else {
13110                                consume();
13111                        }
13112                        }
13113                }
13114                catch (RecognitionException re) {
13115                        _localctx.exception = re;
13116                        _errHandler.reportError(this, re);
13117                        _errHandler.recover(this, re);
13118                }
13119                finally {
13120                        exitRule();
13121                }
13122                return _localctx;
13123        }
13124
13125        public static class LinkTagContext extends ParserRuleContext {
13126                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13127                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13128                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13129                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13130                public List<AttributeContext> attribute() {
13131                        return getRuleContexts(AttributeContext.class);
13132                }
13133                public AttributeContext attribute(int i) {
13134                        return getRuleContext(AttributeContext.class,i);
13135                }
13136                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13137                public TerminalNode NEWLINE(int i) {
13138                        return getToken(JavadocParser.NEWLINE, i);
13139                }
13140                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13141                public TerminalNode LEADING_ASTERISK(int i) {
13142                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13143                }
13144                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13145                public TerminalNode WS(int i) {
13146                        return getToken(JavadocParser.WS, i);
13147                }
13148                public LinkTagContext(ParserRuleContext parent, int invokingState) {
13149                        super(parent, invokingState);
13150                }
13151                @Override public int getRuleIndex() { return RULE_linkTag; }
13152                @Override
13153                public void enterRule(ParseTreeListener listener) {
13154                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this);
13155                }
13156                @Override
13157                public void exitRule(ParseTreeListener listener) {
13158                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this);
13159                }
13160                @Override
13161                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13162                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this);
13163                        else return visitor.visitChildren(this);
13164                }
13165        }
13166
13167        public final LinkTagContext linkTag() throws RecognitionException {
13168                LinkTagContext _localctx = new LinkTagContext(_ctx, getState());
13169                enterRule(_localctx, 126, RULE_linkTag);
13170                int _la;
13171                try {
13172                        enterOuterAlt(_localctx, 1);
13173                        {
13174                        setState(1501);
13175                        match(OPEN);
13176                        setState(1502);
13177                        match(LINK_HTML_TAG_NAME);
13178                        setState(1509);
13179                        _errHandler.sync(this);
13180                        _la = _input.LA(1);
13181                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13182                                {
13183                                setState(1507);
13184                                switch (_input.LA(1)) {
13185                                case HTML_TAG_NAME:
13186                                        {
13187                                        setState(1503);
13188                                        attribute();
13189                                        }
13190                                        break;
13191                                case NEWLINE:
13192                                        {
13193                                        setState(1504);
13194                                        match(NEWLINE);
13195                                        }
13196                                        break;
13197                                case LEADING_ASTERISK:
13198                                        {
13199                                        setState(1505);
13200                                        match(LEADING_ASTERISK);
13201                                        }
13202                                        break;
13203                                case WS:
13204                                        {
13205                                        setState(1506);
13206                                        match(WS);
13207                                        }
13208                                        break;
13209                                default:
13210                                        throw new NoViableAltException(this);
13211                                }
13212                                }
13213                                setState(1511);
13214                                _errHandler.sync(this);
13215                                _la = _input.LA(1);
13216                        }
13217                        setState(1512);
13218                        _la = _input.LA(1);
13219                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13220                        _errHandler.recoverInline(this);
13221                        } else {
13222                                consume();
13223                        }
13224                        }
13225                }
13226                catch (RecognitionException re) {
13227                        _localctx.exception = re;
13228                        _errHandler.reportError(this, re);
13229                        _errHandler.recover(this, re);
13230                }
13231                finally {
13232                        exitRule();
13233                }
13234                return _localctx;
13235        }
13236
13237        public static class MetaTagContext extends ParserRuleContext {
13238                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13239                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13240                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13241                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13242                public List<AttributeContext> attribute() {
13243                        return getRuleContexts(AttributeContext.class);
13244                }
13245                public AttributeContext attribute(int i) {
13246                        return getRuleContext(AttributeContext.class,i);
13247                }
13248                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13249                public TerminalNode NEWLINE(int i) {
13250                        return getToken(JavadocParser.NEWLINE, i);
13251                }
13252                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13253                public TerminalNode LEADING_ASTERISK(int i) {
13254                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13255                }
13256                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13257                public TerminalNode WS(int i) {
13258                        return getToken(JavadocParser.WS, i);
13259                }
13260                public MetaTagContext(ParserRuleContext parent, int invokingState) {
13261                        super(parent, invokingState);
13262                }
13263                @Override public int getRuleIndex() { return RULE_metaTag; }
13264                @Override
13265                public void enterRule(ParseTreeListener listener) {
13266                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this);
13267                }
13268                @Override
13269                public void exitRule(ParseTreeListener listener) {
13270                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this);
13271                }
13272                @Override
13273                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13274                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this);
13275                        else return visitor.visitChildren(this);
13276                }
13277        }
13278
13279        public final MetaTagContext metaTag() throws RecognitionException {
13280                MetaTagContext _localctx = new MetaTagContext(_ctx, getState());
13281                enterRule(_localctx, 128, RULE_metaTag);
13282                int _la;
13283                try {
13284                        enterOuterAlt(_localctx, 1);
13285                        {
13286                        setState(1514);
13287                        match(OPEN);
13288                        setState(1515);
13289                        match(META_HTML_TAG_NAME);
13290                        setState(1522);
13291                        _errHandler.sync(this);
13292                        _la = _input.LA(1);
13293                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13294                                {
13295                                setState(1520);
13296                                switch (_input.LA(1)) {
13297                                case HTML_TAG_NAME:
13298                                        {
13299                                        setState(1516);
13300                                        attribute();
13301                                        }
13302                                        break;
13303                                case NEWLINE:
13304                                        {
13305                                        setState(1517);
13306                                        match(NEWLINE);
13307                                        }
13308                                        break;
13309                                case LEADING_ASTERISK:
13310                                        {
13311                                        setState(1518);
13312                                        match(LEADING_ASTERISK);
13313                                        }
13314                                        break;
13315                                case WS:
13316                                        {
13317                                        setState(1519);
13318                                        match(WS);
13319                                        }
13320                                        break;
13321                                default:
13322                                        throw new NoViableAltException(this);
13323                                }
13324                                }
13325                                setState(1524);
13326                                _errHandler.sync(this);
13327                                _la = _input.LA(1);
13328                        }
13329                        setState(1525);
13330                        _la = _input.LA(1);
13331                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13332                        _errHandler.recoverInline(this);
13333                        } else {
13334                                consume();
13335                        }
13336                        }
13337                }
13338                catch (RecognitionException re) {
13339                        _localctx.exception = re;
13340                        _errHandler.reportError(this, re);
13341                        _errHandler.recover(this, re);
13342                }
13343                finally {
13344                        exitRule();
13345                }
13346                return _localctx;
13347        }
13348
13349        public static class ParamTagContext extends ParserRuleContext {
13350                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13351                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13352                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13353                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13354                public List<AttributeContext> attribute() {
13355                        return getRuleContexts(AttributeContext.class);
13356                }
13357                public AttributeContext attribute(int i) {
13358                        return getRuleContext(AttributeContext.class,i);
13359                }
13360                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13361                public TerminalNode NEWLINE(int i) {
13362                        return getToken(JavadocParser.NEWLINE, i);
13363                }
13364                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13365                public TerminalNode LEADING_ASTERISK(int i) {
13366                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13367                }
13368                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13369                public TerminalNode WS(int i) {
13370                        return getToken(JavadocParser.WS, i);
13371                }
13372                public ParamTagContext(ParserRuleContext parent, int invokingState) {
13373                        super(parent, invokingState);
13374                }
13375                @Override public int getRuleIndex() { return RULE_paramTag; }
13376                @Override
13377                public void enterRule(ParseTreeListener listener) {
13378                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this);
13379                }
13380                @Override
13381                public void exitRule(ParseTreeListener listener) {
13382                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this);
13383                }
13384                @Override
13385                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13386                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this);
13387                        else return visitor.visitChildren(this);
13388                }
13389        }
13390
13391        public final ParamTagContext paramTag() throws RecognitionException {
13392                ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
13393                enterRule(_localctx, 130, RULE_paramTag);
13394                int _la;
13395                try {
13396                        enterOuterAlt(_localctx, 1);
13397                        {
13398                        setState(1527);
13399                        match(OPEN);
13400                        setState(1528);
13401                        match(PARAM_HTML_TAG_NAME);
13402                        setState(1535);
13403                        _errHandler.sync(this);
13404                        _la = _input.LA(1);
13405                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13406                                {
13407                                setState(1533);
13408                                switch (_input.LA(1)) {
13409                                case HTML_TAG_NAME:
13410                                        {
13411                                        setState(1529);
13412                                        attribute();
13413                                        }
13414                                        break;
13415                                case NEWLINE:
13416                                        {
13417                                        setState(1530);
13418                                        match(NEWLINE);
13419                                        }
13420                                        break;
13421                                case LEADING_ASTERISK:
13422                                        {
13423                                        setState(1531);
13424                                        match(LEADING_ASTERISK);
13425                                        }
13426                                        break;
13427                                case WS:
13428                                        {
13429                                        setState(1532);
13430                                        match(WS);
13431                                        }
13432                                        break;
13433                                default:
13434                                        throw new NoViableAltException(this);
13435                                }
13436                                }
13437                                setState(1537);
13438                                _errHandler.sync(this);
13439                                _la = _input.LA(1);
13440                        }
13441                        setState(1538);
13442                        _la = _input.LA(1);
13443                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13444                        _errHandler.recoverInline(this);
13445                        } else {
13446                                consume();
13447                        }
13448                        }
13449                }
13450                catch (RecognitionException re) {
13451                        _localctx.exception = re;
13452                        _errHandler.reportError(this, re);
13453                        _errHandler.recover(this, re);
13454                }
13455                finally {
13456                        exitRule();
13457                }
13458                return _localctx;
13459        }
13460
13461        public static class WrongSinletonTagContext extends ParserRuleContext {
13462                public SingletonTagNameContext singletonTagName;
13463                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13464                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
13465                public SingletonTagNameContext singletonTagName() {
13466                        return getRuleContext(SingletonTagNameContext.class,0);
13467                }
13468                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13469                public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) {
13470                        super(parent, invokingState);
13471                }
13472                @Override public int getRuleIndex() { return RULE_wrongSinletonTag; }
13473                @Override
13474                public void enterRule(ParseTreeListener listener) {
13475                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this);
13476                }
13477                @Override
13478                public void exitRule(ParseTreeListener listener) {
13479                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this);
13480                }
13481                @Override
13482                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13483                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this);
13484                        else return visitor.visitChildren(this);
13485                }
13486        }
13487
13488        public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException {
13489                WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState());
13490                enterRule(_localctx, 132, RULE_wrongSinletonTag);
13491                try {
13492                        enterOuterAlt(_localctx, 1);
13493                        {
13494                        setState(1540);
13495                        match(OPEN);
13496                        setState(1541);
13497                        match(SLASH);
13498                        setState(1542);
13499                        ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName();
13500                        setState(1543);
13501                        match(CLOSE);
13502                        notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), "javadoc.wrong.singleton.html.tag", null);
13503                        }
13504                }
13505                catch (RecognitionException re) {
13506                        _localctx.exception = re;
13507                        _errHandler.reportError(this, re);
13508                        _errHandler.recover(this, re);
13509                }
13510                finally {
13511                        exitRule();
13512                }
13513                return _localctx;
13514        }
13515
13516        public static class SingletonTagNameContext extends ParserRuleContext {
13517                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
13518                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
13519                public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); }
13520                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
13521                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
13522                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
13523                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
13524                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
13525                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13526                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13527                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13528                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13529                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13530                public SingletonTagNameContext(ParserRuleContext parent, int invokingState) {
13531                        super(parent, invokingState);
13532                }
13533                @Override public int getRuleIndex() { return RULE_singletonTagName; }
13534                @Override
13535                public void enterRule(ParseTreeListener listener) {
13536                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this);
13537                }
13538                @Override
13539                public void exitRule(ParseTreeListener listener) {
13540                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this);
13541                }
13542                @Override
13543                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13544                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this);
13545                        else return visitor.visitChildren(this);
13546                }
13547        }
13548
13549        public final SingletonTagNameContext singletonTagName() throws RecognitionException {
13550                SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState());
13551                enterRule(_localctx, 134, RULE_singletonTagName);
13552                int _la;
13553                try {
13554                        enterOuterAlt(_localctx, 1);
13555                        {
13556                        setState(1546);
13557                        _la = _input.LA(1);
13558                        if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFRONT_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)) ) {
13559                        _errHandler.recoverInline(this);
13560                        } else {
13561                                consume();
13562                        }
13563                        }
13564                }
13565                catch (RecognitionException re) {
13566                        _localctx.exception = re;
13567                        _errHandler.reportError(this, re);
13568                        _errHandler.recover(this, re);
13569                }
13570                finally {
13571                        exitRule();
13572                }
13573                return _localctx;
13574        }
13575
13576        public static class DescriptionContext extends ParserRuleContext {
13577                public List<HtmlCommentContext> htmlComment() {
13578                        return getRuleContexts(HtmlCommentContext.class);
13579                }
13580                public HtmlCommentContext htmlComment(int i) {
13581                        return getRuleContext(HtmlCommentContext.class,i);
13582                }
13583                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
13584                public TerminalNode CDATA(int i) {
13585                        return getToken(JavadocParser.CDATA, i);
13586                }
13587                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13588                public TerminalNode NEWLINE(int i) {
13589                        return getToken(JavadocParser.NEWLINE, i);
13590                }
13591                public List<TextContext> text() {
13592                        return getRuleContexts(TextContext.class);
13593                }
13594                public TextContext text(int i) {
13595                        return getRuleContext(TextContext.class,i);
13596                }
13597                public List<JavadocInlineTagContext> javadocInlineTag() {
13598                        return getRuleContexts(JavadocInlineTagContext.class);
13599                }
13600                public JavadocInlineTagContext javadocInlineTag(int i) {
13601                        return getRuleContext(JavadocInlineTagContext.class,i);
13602                }
13603                public List<HtmlElementContext> htmlElement() {
13604                        return getRuleContexts(HtmlElementContext.class);
13605                }
13606                public HtmlElementContext htmlElement(int i) {
13607                        return getRuleContext(HtmlElementContext.class,i);
13608                }
13609                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13610                public TerminalNode LEADING_ASTERISK(int i) {
13611                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13612                }
13613                public DescriptionContext(ParserRuleContext parent, int invokingState) {
13614                        super(parent, invokingState);
13615                }
13616                @Override public int getRuleIndex() { return RULE_description; }
13617                @Override
13618                public void enterRule(ParseTreeListener listener) {
13619                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
13620                }
13621                @Override
13622                public void exitRule(ParseTreeListener listener) {
13623                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
13624                }
13625                @Override
13626                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13627                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
13628                        else return visitor.visitChildren(this);
13629                }
13630        }
13631
13632        public final DescriptionContext description() throws RecognitionException {
13633                DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
13634                enterRule(_localctx, 136, RULE_description);
13635                try {
13636                        int _alt;
13637                        enterOuterAlt(_localctx, 1);
13638                        {
13639                        setState(1556); 
13640                        _errHandler.sync(this);
13641                        _alt = 1;
13642                        do {
13643                                switch (_alt) {
13644                                case 1:
13645                                        {
13646                                        setState(1556);
13647                                        switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
13648                                        case 1:
13649                                                {
13650                                                {
13651                                                setState(1548);
13652                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
13653                                                setState(1549);
13654                                                match(LEADING_ASTERISK);
13655                                                }
13656                                                }
13657                                                break;
13658                                        case 2:
13659                                                {
13660                                                setState(1550);
13661                                                htmlComment();
13662                                                }
13663                                                break;
13664                                        case 3:
13665                                                {
13666                                                setState(1551);
13667                                                match(CDATA);
13668                                                }
13669                                                break;
13670                                        case 4:
13671                                                {
13672                                                setState(1552);
13673                                                match(NEWLINE);
13674                                                }
13675                                                break;
13676                                        case 5:
13677                                                {
13678                                                setState(1553);
13679                                                text();
13680                                                }
13681                                                break;
13682                                        case 6:
13683                                                {
13684                                                setState(1554);
13685                                                javadocInlineTag();
13686                                                }
13687                                                break;
13688                                        case 7:
13689                                                {
13690                                                setState(1555);
13691                                                htmlElement();
13692                                                }
13693                                                break;
13694                                        }
13695                                        }
13696                                        break;
13697                                default:
13698                                        throw new NoViableAltException(this);
13699                                }
13700                                setState(1558); 
13701                                _errHandler.sync(this);
13702                                _alt = getInterpreter().adaptivePredict(_input,122,_ctx);
13703                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13704                        }
13705                }
13706                catch (RecognitionException re) {
13707                        _localctx.exception = re;
13708                        _errHandler.reportError(this, re);
13709                        _errHandler.recover(this, re);
13710                }
13711                finally {
13712                        exitRule();
13713                }
13714                return _localctx;
13715        }
13716
13717        public static class ReferenceContext extends ParserRuleContext {
13718                public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); }
13719                public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); }
13720                public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); }
13721                public ParametersContext parameters() {
13722                        return getRuleContext(ParametersContext.class,0);
13723                }
13724                public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); }
13725                public TerminalNode DOT(int i) {
13726                        return getToken(JavadocParser.DOT, i);
13727                }
13728                public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); }
13729                public TerminalNode CLASS(int i) {
13730                        return getToken(JavadocParser.CLASS, i);
13731                }
13732                public ReferenceContext(ParserRuleContext parent, int invokingState) {
13733                        super(parent, invokingState);
13734                }
13735                @Override public int getRuleIndex() { return RULE_reference; }
13736                @Override
13737                public void enterRule(ParseTreeListener listener) {
13738                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this);
13739                }
13740                @Override
13741                public void exitRule(ParseTreeListener listener) {
13742                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this);
13743                }
13744                @Override
13745                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13746                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this);
13747                        else return visitor.visitChildren(this);
13748                }
13749        }
13750
13751        public final ReferenceContext reference() throws RecognitionException {
13752                ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
13753                enterRule(_localctx, 138, RULE_reference);
13754                int _la;
13755                try {
13756                        int _alt;
13757                        enterOuterAlt(_localctx, 1);
13758                        {
13759                        setState(1597);
13760                        switch (_input.LA(1)) {
13761                        case PACKAGE:
13762                                {
13763                                setState(1560);
13764                                match(PACKAGE);
13765                                setState(1564);
13766                                _errHandler.sync(this);
13767                                _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13768                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13769                                        if ( _alt==1 ) {
13770                                                {
13771                                                {
13772                                                setState(1561);
13773                                                _la = _input.LA(1);
13774                                                if ( !(_la==DOT || _la==CLASS) ) {
13775                                                _errHandler.recoverInline(this);
13776                                                } else {
13777                                                        consume();
13778                                                }
13779                                                }
13780                                                } 
13781                                        }
13782                                        setState(1566);
13783                                        _errHandler.sync(this);
13784                                        _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13785                                }
13786                                setState(1568);
13787                                switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
13788                                case 1:
13789                                        {
13790                                        setState(1567);
13791                                        match(HASH);
13792                                        }
13793                                        break;
13794                                }
13795                                setState(1571);
13796                                switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
13797                                case 1:
13798                                        {
13799                                        setState(1570);
13800                                        match(MEMBER);
13801                                        }
13802                                        break;
13803                                }
13804                                setState(1574);
13805                                switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
13806                                case 1:
13807                                        {
13808                                        setState(1573);
13809                                        parameters();
13810                                        }
13811                                        break;
13812                                }
13813                                }
13814                                break;
13815                        case DOT:
13816                        case CLASS:
13817                                {
13818                                setState(1577); 
13819                                _errHandler.sync(this);
13820                                _alt = 1;
13821                                do {
13822                                        switch (_alt) {
13823                                        case 1:
13824                                                {
13825                                                {
13826                                                setState(1576);
13827                                                _la = _input.LA(1);
13828                                                if ( !(_la==DOT || _la==CLASS) ) {
13829                                                _errHandler.recoverInline(this);
13830                                                } else {
13831                                                        consume();
13832                                                }
13833                                                }
13834                                                }
13835                                                break;
13836                                        default:
13837                                                throw new NoViableAltException(this);
13838                                        }
13839                                        setState(1579); 
13840                                        _errHandler.sync(this);
13841                                        _alt = getInterpreter().adaptivePredict(_input,127,_ctx);
13842                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13843                                setState(1582);
13844                                switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
13845                                case 1:
13846                                        {
13847                                        setState(1581);
13848                                        match(HASH);
13849                                        }
13850                                        break;
13851                                }
13852                                setState(1585);
13853                                switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
13854                                case 1:
13855                                        {
13856                                        setState(1584);
13857                                        match(MEMBER);
13858                                        }
13859                                        break;
13860                                }
13861                                setState(1588);
13862                                switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
13863                                case 1:
13864                                        {
13865                                        setState(1587);
13866                                        parameters();
13867                                        }
13868                                        break;
13869                                }
13870                                }
13871                                break;
13872                        case HASH:
13873                        case MEMBER:
13874                                {
13875                                setState(1591);
13876                                _la = _input.LA(1);
13877                                if (_la==HASH) {
13878                                        {
13879                                        setState(1590);
13880                                        match(HASH);
13881                                        }
13882                                }
13883
13884                                setState(1593);
13885                                match(MEMBER);
13886                                setState(1595);
13887                                switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
13888                                case 1:
13889                                        {
13890                                        setState(1594);
13891                                        parameters();
13892                                        }
13893                                        break;
13894                                }
13895                                }
13896                                break;
13897                        default:
13898                                throw new NoViableAltException(this);
13899                        }
13900                        }
13901                }
13902                catch (RecognitionException re) {
13903                        _localctx.exception = re;
13904                        _errHandler.reportError(this, re);
13905                        _errHandler.recover(this, re);
13906                }
13907                finally {
13908                        exitRule();
13909                }
13910                return _localctx;
13911        }
13912
13913        public static class ParametersContext extends ParserRuleContext {
13914                public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); }
13915                public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); }
13916                public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); }
13917                public TerminalNode ARGUMENT(int i) {
13918                        return getToken(JavadocParser.ARGUMENT, i);
13919                }
13920                public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); }
13921                public TerminalNode COMMA(int i) {
13922                        return getToken(JavadocParser.COMMA, i);
13923                }
13924                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13925                public TerminalNode WS(int i) {
13926                        return getToken(JavadocParser.WS, i);
13927                }
13928                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13929                public TerminalNode NEWLINE(int i) {
13930                        return getToken(JavadocParser.NEWLINE, i);
13931                }
13932                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13933                public TerminalNode LEADING_ASTERISK(int i) {
13934                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13935                }
13936                public ParametersContext(ParserRuleContext parent, int invokingState) {
13937                        super(parent, invokingState);
13938                }
13939                @Override public int getRuleIndex() { return RULE_parameters; }
13940                @Override
13941                public void enterRule(ParseTreeListener listener) {
13942                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this);
13943                }
13944                @Override
13945                public void exitRule(ParseTreeListener listener) {
13946                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this);
13947                }
13948                @Override
13949                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13950                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this);
13951                        else return visitor.visitChildren(this);
13952                }
13953        }
13954
13955        public final ParametersContext parameters() throws RecognitionException {
13956                ParametersContext _localctx = new ParametersContext(_ctx, getState());
13957                enterRule(_localctx, 140, RULE_parameters);
13958                int _la;
13959                try {
13960                        enterOuterAlt(_localctx, 1);
13961                        {
13962                        setState(1599);
13963                        match(LEFT_BRACE);
13964                        setState(1603);
13965                        _errHandler.sync(this);
13966                        _la = _input.LA(1);
13967                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) {
13968                                {
13969                                {
13970                                setState(1600);
13971                                _la = _input.LA(1);
13972                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) {
13973                                _errHandler.recoverInline(this);
13974                                } else {
13975                                        consume();
13976                                }
13977                                }
13978                                }
13979                                setState(1605);
13980                                _errHandler.sync(this);
13981                                _la = _input.LA(1);
13982                        }
13983                        setState(1606);
13984                        match(RIGHT_BRACE);
13985                        }
13986                }
13987                catch (RecognitionException re) {
13988                        _localctx.exception = re;
13989                        _errHandler.reportError(this, re);
13990                        _errHandler.recover(this, re);
13991                }
13992                finally {
13993                        exitRule();
13994                }
13995                return _localctx;
13996        }
13997
13998        public static class JavadocTagContext extends ParserRuleContext {
13999                public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); }
14000                public DescriptionContext description() {
14001                        return getRuleContext(DescriptionContext.class,0);
14002                }
14003                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14004                public TerminalNode WS(int i) {
14005                        return getToken(JavadocParser.WS, i);
14006                }
14007                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14008                public TerminalNode NEWLINE(int i) {
14009                        return getToken(JavadocParser.NEWLINE, i);
14010                }
14011                public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); }
14012                public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); }
14013                public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); }
14014                public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); }
14015                public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); }
14016                public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); }
14017                public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); }
14018                public ReferenceContext reference() {
14019                        return getRuleContext(ReferenceContext.class,0);
14020                }
14021                public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); }
14022                public TerminalNode STRING(int i) {
14023                        return getToken(JavadocParser.STRING, i);
14024                }
14025                public List<HtmlElementContext> htmlElement() {
14026                        return getRuleContexts(HtmlElementContext.class);
14027                }
14028                public HtmlElementContext htmlElement(int i) {
14029                        return getRuleContext(HtmlElementContext.class,i);
14030                }
14031                public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); }
14032                public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); }
14033                public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); }
14034                public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); }
14035                public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); }
14036                public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); }
14037                public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); }
14038                public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); }
14039                public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); }
14040                public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); }
14041                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14042                public JavadocTagContext(ParserRuleContext parent, int invokingState) {
14043                        super(parent, invokingState);
14044                }
14045                @Override public int getRuleIndex() { return RULE_javadocTag; }
14046                @Override
14047                public void enterRule(ParseTreeListener listener) {
14048                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this);
14049                }
14050                @Override
14051                public void exitRule(ParseTreeListener listener) {
14052                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this);
14053                }
14054                @Override
14055                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14056                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this);
14057                        else return visitor.visitChildren(this);
14058                }
14059        }
14060
14061        public final JavadocTagContext javadocTag() throws RecognitionException {
14062                JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState());
14063                enterRule(_localctx, 142, RULE_javadocTag);
14064                int _la;
14065                try {
14066                        int _alt;
14067                        setState(1802);
14068                        switch (_input.LA(1)) {
14069                        case AUTHOR_LITERAL:
14070                                enterOuterAlt(_localctx, 1);
14071                                {
14072                                setState(1608);
14073                                match(AUTHOR_LITERAL);
14074                                setState(1612);
14075                                _errHandler.sync(this);
14076                                _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14077                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14078                                        if ( _alt==1 ) {
14079                                                {
14080                                                {
14081                                                setState(1609);
14082                                                _la = _input.LA(1);
14083                                                if ( !(_la==WS || _la==NEWLINE) ) {
14084                                                _errHandler.recoverInline(this);
14085                                                } else {
14086                                                        consume();
14087                                                }
14088                                                }
14089                                                } 
14090                                        }
14091                                        setState(1614);
14092                                        _errHandler.sync(this);
14093                                        _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14094                                }
14095                                setState(1616);
14096                                switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
14097                                case 1:
14098                                        {
14099                                        setState(1615);
14100                                        description();
14101                                        }
14102                                        break;
14103                                }
14104                                }
14105                                break;
14106                        case DEPRECATED_LITERAL:
14107                                enterOuterAlt(_localctx, 2);
14108                                {
14109                                setState(1618);
14110                                match(DEPRECATED_LITERAL);
14111                                setState(1622);
14112                                _errHandler.sync(this);
14113                                _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14114                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14115                                        if ( _alt==1 ) {
14116                                                {
14117                                                {
14118                                                setState(1619);
14119                                                _la = _input.LA(1);
14120                                                if ( !(_la==WS || _la==NEWLINE) ) {
14121                                                _errHandler.recoverInline(this);
14122                                                } else {
14123                                                        consume();
14124                                                }
14125                                                }
14126                                                } 
14127                                        }
14128                                        setState(1624);
14129                                        _errHandler.sync(this);
14130                                        _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14131                                }
14132                                setState(1626);
14133                                switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
14134                                case 1:
14135                                        {
14136                                        setState(1625);
14137                                        description();
14138                                        }
14139                                        break;
14140                                }
14141                                }
14142                                break;
14143                        case EXCEPTION_LITERAL:
14144                                enterOuterAlt(_localctx, 3);
14145                                {
14146                                setState(1628);
14147                                match(EXCEPTION_LITERAL);
14148                                setState(1632);
14149                                _errHandler.sync(this);
14150                                _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14151                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14152                                        if ( _alt==1 ) {
14153                                                {
14154                                                {
14155                                                setState(1629);
14156                                                _la = _input.LA(1);
14157                                                if ( !(_la==WS || _la==NEWLINE) ) {
14158                                                _errHandler.recoverInline(this);
14159                                                } else {
14160                                                        consume();
14161                                                }
14162                                                }
14163                                                } 
14164                                        }
14165                                        setState(1634);
14166                                        _errHandler.sync(this);
14167                                        _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14168                                }
14169                                setState(1636);
14170                                switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
14171                                case 1:
14172                                        {
14173                                        setState(1635);
14174                                        match(CLASS_NAME);
14175                                        }
14176                                        break;
14177                                }
14178                                setState(1641);
14179                                _errHandler.sync(this);
14180                                _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14181                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14182                                        if ( _alt==1 ) {
14183                                                {
14184                                                {
14185                                                setState(1638);
14186                                                _la = _input.LA(1);
14187                                                if ( !(_la==WS || _la==NEWLINE) ) {
14188                                                _errHandler.recoverInline(this);
14189                                                } else {
14190                                                        consume();
14191                                                }
14192                                                }
14193                                                } 
14194                                        }
14195                                        setState(1643);
14196                                        _errHandler.sync(this);
14197                                        _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14198                                }
14199                                setState(1645);
14200                                switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
14201                                case 1:
14202                                        {
14203                                        setState(1644);
14204                                        description();
14205                                        }
14206                                        break;
14207                                }
14208                                }
14209                                break;
14210                        case PARAM_LITERAL:
14211                                enterOuterAlt(_localctx, 4);
14212                                {
14213                                setState(1647);
14214                                match(PARAM_LITERAL);
14215                                setState(1651);
14216                                _errHandler.sync(this);
14217                                _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14218                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14219                                        if ( _alt==1 ) {
14220                                                {
14221                                                {
14222                                                setState(1648);
14223                                                _la = _input.LA(1);
14224                                                if ( !(_la==WS || _la==NEWLINE) ) {
14225                                                _errHandler.recoverInline(this);
14226                                                } else {
14227                                                        consume();
14228                                                }
14229                                                }
14230                                                } 
14231                                        }
14232                                        setState(1653);
14233                                        _errHandler.sync(this);
14234                                        _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14235                                }
14236                                setState(1655);
14237                                switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
14238                                case 1:
14239                                        {
14240                                        setState(1654);
14241                                        match(PARAMETER_NAME);
14242                                        }
14243                                        break;
14244                                }
14245                                setState(1660);
14246                                _errHandler.sync(this);
14247                                _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14248                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14249                                        if ( _alt==1 ) {
14250                                                {
14251                                                {
14252                                                setState(1657);
14253                                                _la = _input.LA(1);
14254                                                if ( !(_la==WS || _la==NEWLINE) ) {
14255                                                _errHandler.recoverInline(this);
14256                                                } else {
14257                                                        consume();
14258                                                }
14259                                                }
14260                                                } 
14261                                        }
14262                                        setState(1662);
14263                                        _errHandler.sync(this);
14264                                        _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14265                                }
14266                                setState(1664);
14267                                switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
14268                                case 1:
14269                                        {
14270                                        setState(1663);
14271                                        description();
14272                                        }
14273                                        break;
14274                                }
14275                                }
14276                                break;
14277                        case RETURN_LITERAL:
14278                                enterOuterAlt(_localctx, 5);
14279                                {
14280                                setState(1666);
14281                                match(RETURN_LITERAL);
14282                                setState(1670);
14283                                _errHandler.sync(this);
14284                                _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14285                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14286                                        if ( _alt==1 ) {
14287                                                {
14288                                                {
14289                                                setState(1667);
14290                                                _la = _input.LA(1);
14291                                                if ( !(_la==WS || _la==NEWLINE) ) {
14292                                                _errHandler.recoverInline(this);
14293                                                } else {
14294                                                        consume();
14295                                                }
14296                                                }
14297                                                } 
14298                                        }
14299                                        setState(1672);
14300                                        _errHandler.sync(this);
14301                                        _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14302                                }
14303                                setState(1674);
14304                                switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
14305                                case 1:
14306                                        {
14307                                        setState(1673);
14308                                        description();
14309                                        }
14310                                        break;
14311                                }
14312                                }
14313                                break;
14314                        case SEE_LITERAL:
14315                                enterOuterAlt(_localctx, 6);
14316                                {
14317                                setState(1676);
14318                                match(SEE_LITERAL);
14319                                setState(1680);
14320                                _errHandler.sync(this);
14321                                _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14322                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14323                                        if ( _alt==1 ) {
14324                                                {
14325                                                {
14326                                                setState(1677);
14327                                                _la = _input.LA(1);
14328                                                if ( !(_la==WS || _la==NEWLINE) ) {
14329                                                _errHandler.recoverInline(this);
14330                                                } else {
14331                                                        consume();
14332                                                }
14333                                                }
14334                                                } 
14335                                        }
14336                                        setState(1682);
14337                                        _errHandler.sync(this);
14338                                        _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14339                                }
14340                                setState(1684);
14341                                switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
14342                                case 1:
14343                                        {
14344                                        setState(1683);
14345                                        reference();
14346                                        }
14347                                        break;
14348                                }
14349                                setState(1690);
14350                                _errHandler.sync(this);
14351                                _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14352                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14353                                        if ( _alt==1 ) {
14354                                                {
14355                                                setState(1688);
14356                                                switch (_input.LA(1)) {
14357                                                case STRING:
14358                                                        {
14359                                                        setState(1686);
14360                                                        match(STRING);
14361                                                        }
14362                                                        break;
14363                                                case OPEN:
14364                                                        {
14365                                                        setState(1687);
14366                                                        htmlElement();
14367                                                        }
14368                                                        break;
14369                                                default:
14370                                                        throw new NoViableAltException(this);
14371                                                }
14372                                                } 
14373                                        }
14374                                        setState(1692);
14375                                        _errHandler.sync(this);
14376                                        _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14377                                }
14378                                setState(1696);
14379                                _errHandler.sync(this);
14380                                _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14381                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14382                                        if ( _alt==1 ) {
14383                                                {
14384                                                {
14385                                                setState(1693);
14386                                                _la = _input.LA(1);
14387                                                if ( !(_la==WS || _la==NEWLINE) ) {
14388                                                _errHandler.recoverInline(this);
14389                                                } else {
14390                                                        consume();
14391                                                }
14392                                                }
14393                                                } 
14394                                        }
14395                                        setState(1698);
14396                                        _errHandler.sync(this);
14397                                        _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14398                                }
14399                                setState(1700);
14400                                switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
14401                                case 1:
14402                                        {
14403                                        setState(1699);
14404                                        description();
14405                                        }
14406                                        break;
14407                                }
14408                                }
14409                                break;
14410                        case SERIAL_LITERAL:
14411                                enterOuterAlt(_localctx, 7);
14412                                {
14413                                setState(1702);
14414                                match(SERIAL_LITERAL);
14415                                setState(1706);
14416                                _errHandler.sync(this);
14417                                _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14418                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14419                                        if ( _alt==1 ) {
14420                                                {
14421                                                {
14422                                                setState(1703);
14423                                                _la = _input.LA(1);
14424                                                if ( !(_la==WS || _la==NEWLINE) ) {
14425                                                _errHandler.recoverInline(this);
14426                                                } else {
14427                                                        consume();
14428                                                }
14429                                                }
14430                                                } 
14431                                        }
14432                                        setState(1708);
14433                                        _errHandler.sync(this);
14434                                        _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14435                                }
14436                                setState(1710);
14437                                switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
14438                                case 1:
14439                                        {
14440                                        setState(1709);
14441                                        _la = _input.LA(1);
14442                                        if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) {
14443                                        _errHandler.recoverInline(this);
14444                                        } else {
14445                                                consume();
14446                                        }
14447                                        }
14448                                        break;
14449                                }
14450                                setState(1713);
14451                                switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
14452                                case 1:
14453                                        {
14454                                        setState(1712);
14455                                        description();
14456                                        }
14457                                        break;
14458                                }
14459                                }
14460                                break;
14461                        case SERIAL_DATA_LITERAL:
14462                                enterOuterAlt(_localctx, 8);
14463                                {
14464                                setState(1715);
14465                                match(SERIAL_DATA_LITERAL);
14466                                setState(1719);
14467                                _errHandler.sync(this);
14468                                _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14469                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14470                                        if ( _alt==1 ) {
14471                                                {
14472                                                {
14473                                                setState(1716);
14474                                                _la = _input.LA(1);
14475                                                if ( !(_la==WS || _la==NEWLINE) ) {
14476                                                _errHandler.recoverInline(this);
14477                                                } else {
14478                                                        consume();
14479                                                }
14480                                                }
14481                                                } 
14482                                        }
14483                                        setState(1721);
14484                                        _errHandler.sync(this);
14485                                        _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14486                                }
14487                                setState(1723);
14488                                switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
14489                                case 1:
14490                                        {
14491                                        setState(1722);
14492                                        description();
14493                                        }
14494                                        break;
14495                                }
14496                                }
14497                                break;
14498                        case SERIAL_FIELD_LITERAL:
14499                                enterOuterAlt(_localctx, 9);
14500                                {
14501                                setState(1725);
14502                                match(SERIAL_FIELD_LITERAL);
14503                                setState(1729);
14504                                _errHandler.sync(this);
14505                                _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14506                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14507                                        if ( _alt==1 ) {
14508                                                {
14509                                                {
14510                                                setState(1726);
14511                                                _la = _input.LA(1);
14512                                                if ( !(_la==WS || _la==NEWLINE) ) {
14513                                                _errHandler.recoverInline(this);
14514                                                } else {
14515                                                        consume();
14516                                                }
14517                                                }
14518                                                } 
14519                                        }
14520                                        setState(1731);
14521                                        _errHandler.sync(this);
14522                                        _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14523                                }
14524                                setState(1733);
14525                                switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
14526                                case 1:
14527                                        {
14528                                        setState(1732);
14529                                        match(FIELD_NAME);
14530                                        }
14531                                        break;
14532                                }
14533                                setState(1738);
14534                                _errHandler.sync(this);
14535                                _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14536                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14537                                        if ( _alt==1 ) {
14538                                                {
14539                                                {
14540                                                setState(1735);
14541                                                _la = _input.LA(1);
14542                                                if ( !(_la==WS || _la==NEWLINE) ) {
14543                                                _errHandler.recoverInline(this);
14544                                                } else {
14545                                                        consume();
14546                                                }
14547                                                }
14548                                                } 
14549                                        }
14550                                        setState(1740);
14551                                        _errHandler.sync(this);
14552                                        _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14553                                }
14554                                setState(1742);
14555                                switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
14556                                case 1:
14557                                        {
14558                                        setState(1741);
14559                                        match(FIELD_TYPE);
14560                                        }
14561                                        break;
14562                                }
14563                                setState(1747);
14564                                _errHandler.sync(this);
14565                                _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14566                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14567                                        if ( _alt==1 ) {
14568                                                {
14569                                                {
14570                                                setState(1744);
14571                                                _la = _input.LA(1);
14572                                                if ( !(_la==WS || _la==NEWLINE) ) {
14573                                                _errHandler.recoverInline(this);
14574                                                } else {
14575                                                        consume();
14576                                                }
14577                                                }
14578                                                } 
14579                                        }
14580                                        setState(1749);
14581                                        _errHandler.sync(this);
14582                                        _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14583                                }
14584                                setState(1751);
14585                                switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
14586                                case 1:
14587                                        {
14588                                        setState(1750);
14589                                        description();
14590                                        }
14591                                        break;
14592                                }
14593                                }
14594                                break;
14595                        case SINCE_LITERAL:
14596                                enterOuterAlt(_localctx, 10);
14597                                {
14598                                setState(1753);
14599                                match(SINCE_LITERAL);
14600                                setState(1757);
14601                                _errHandler.sync(this);
14602                                _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14603                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14604                                        if ( _alt==1 ) {
14605                                                {
14606                                                {
14607                                                setState(1754);
14608                                                _la = _input.LA(1);
14609                                                if ( !(_la==WS || _la==NEWLINE) ) {
14610                                                _errHandler.recoverInline(this);
14611                                                } else {
14612                                                        consume();
14613                                                }
14614                                                }
14615                                                } 
14616                                        }
14617                                        setState(1759);
14618                                        _errHandler.sync(this);
14619                                        _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14620                                }
14621                                setState(1761);
14622                                switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
14623                                case 1:
14624                                        {
14625                                        setState(1760);
14626                                        description();
14627                                        }
14628                                        break;
14629                                }
14630                                }
14631                                break;
14632                        case THROWS_LITERAL:
14633                                enterOuterAlt(_localctx, 11);
14634                                {
14635                                setState(1763);
14636                                match(THROWS_LITERAL);
14637                                setState(1767);
14638                                _errHandler.sync(this);
14639                                _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14640                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14641                                        if ( _alt==1 ) {
14642                                                {
14643                                                {
14644                                                setState(1764);
14645                                                _la = _input.LA(1);
14646                                                if ( !(_la==WS || _la==NEWLINE) ) {
14647                                                _errHandler.recoverInline(this);
14648                                                } else {
14649                                                        consume();
14650                                                }
14651                                                }
14652                                                } 
14653                                        }
14654                                        setState(1769);
14655                                        _errHandler.sync(this);
14656                                        _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14657                                }
14658                                setState(1771);
14659                                switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
14660                                case 1:
14661                                        {
14662                                        setState(1770);
14663                                        match(CLASS_NAME);
14664                                        }
14665                                        break;
14666                                }
14667                                setState(1776);
14668                                _errHandler.sync(this);
14669                                _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14670                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14671                                        if ( _alt==1 ) {
14672                                                {
14673                                                {
14674                                                setState(1773);
14675                                                _la = _input.LA(1);
14676                                                if ( !(_la==WS || _la==NEWLINE) ) {
14677                                                _errHandler.recoverInline(this);
14678                                                } else {
14679                                                        consume();
14680                                                }
14681                                                }
14682                                                } 
14683                                        }
14684                                        setState(1778);
14685                                        _errHandler.sync(this);
14686                                        _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14687                                }
14688                                setState(1780);
14689                                switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
14690                                case 1:
14691                                        {
14692                                        setState(1779);
14693                                        description();
14694                                        }
14695                                        break;
14696                                }
14697                                }
14698                                break;
14699                        case VERSION_LITERAL:
14700                                enterOuterAlt(_localctx, 12);
14701                                {
14702                                setState(1782);
14703                                match(VERSION_LITERAL);
14704                                setState(1786);
14705                                _errHandler.sync(this);
14706                                _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14707                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14708                                        if ( _alt==1 ) {
14709                                                {
14710                                                {
14711                                                setState(1783);
14712                                                _la = _input.LA(1);
14713                                                if ( !(_la==WS || _la==NEWLINE) ) {
14714                                                _errHandler.recoverInline(this);
14715                                                } else {
14716                                                        consume();
14717                                                }
14718                                                }
14719                                                } 
14720                                        }
14721                                        setState(1788);
14722                                        _errHandler.sync(this);
14723                                        _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14724                                }
14725                                setState(1790);
14726                                switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
14727                                case 1:
14728                                        {
14729                                        setState(1789);
14730                                        description();
14731                                        }
14732                                        break;
14733                                }
14734                                }
14735                                break;
14736                        case CUSTOM_NAME:
14737                                enterOuterAlt(_localctx, 13);
14738                                {
14739                                setState(1792);
14740                                match(CUSTOM_NAME);
14741                                setState(1796);
14742                                _errHandler.sync(this);
14743                                _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14744                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14745                                        if ( _alt==1 ) {
14746                                                {
14747                                                {
14748                                                setState(1793);
14749                                                _la = _input.LA(1);
14750                                                if ( !(_la==WS || _la==NEWLINE) ) {
14751                                                _errHandler.recoverInline(this);
14752                                                } else {
14753                                                        consume();
14754                                                }
14755                                                }
14756                                                } 
14757                                        }
14758                                        setState(1798);
14759                                        _errHandler.sync(this);
14760                                        _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14761                                }
14762                                setState(1800);
14763                                switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
14764                                case 1:
14765                                        {
14766                                        setState(1799);
14767                                        description();
14768                                        }
14769                                        break;
14770                                }
14771                                }
14772                                break;
14773                        default:
14774                                throw new NoViableAltException(this);
14775                        }
14776                }
14777                catch (RecognitionException re) {
14778                        _localctx.exception = re;
14779                        _errHandler.reportError(this, re);
14780                        _errHandler.recover(this, re);
14781                }
14782                finally {
14783                        exitRule();
14784                }
14785                return _localctx;
14786        }
14787
14788        public static class JavadocInlineTagContext extends ParserRuleContext {
14789                public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); }
14790                public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); }
14791                public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); }
14792                public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); }
14793                public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); }
14794                public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); }
14795                public ReferenceContext reference() {
14796                        return getRuleContext(ReferenceContext.class,0);
14797                }
14798                public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); }
14799                public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); }
14800                public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); }
14801                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14802                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14803                public TerminalNode WS(int i) {
14804                        return getToken(JavadocParser.WS, i);
14805                }
14806                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14807                public TerminalNode NEWLINE(int i) {
14808                        return getToken(JavadocParser.NEWLINE, i);
14809                }
14810                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14811                public TerminalNode LEADING_ASTERISK(int i) {
14812                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14813                }
14814                public List<TextContext> text() {
14815                        return getRuleContexts(TextContext.class);
14816                }
14817                public TextContext text(int i) {
14818                        return getRuleContext(TextContext.class,i);
14819                }
14820                public DescriptionContext description() {
14821                        return getRuleContext(DescriptionContext.class,0);
14822                }
14823                public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) {
14824                        super(parent, invokingState);
14825                }
14826                @Override public int getRuleIndex() { return RULE_javadocInlineTag; }
14827                @Override
14828                public void enterRule(ParseTreeListener listener) {
14829                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this);
14830                }
14831                @Override
14832                public void exitRule(ParseTreeListener listener) {
14833                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this);
14834                }
14835                @Override
14836                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14837                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this);
14838                        else return visitor.visitChildren(this);
14839                }
14840        }
14841
14842        public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException {
14843                JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState());
14844                enterRule(_localctx, 144, RULE_javadocInlineTag);
14845                int _la;
14846                try {
14847                        int _alt;
14848                        enterOuterAlt(_localctx, 1);
14849                        {
14850                        setState(1804);
14851                        match(JAVADOC_INLINE_TAG_START);
14852                        setState(1880);
14853                        switch (_input.LA(1)) {
14854                        case CODE_LITERAL:
14855                                {
14856                                setState(1805);
14857                                match(CODE_LITERAL);
14858                                setState(1812);
14859                                _errHandler.sync(this);
14860                                _la = _input.LA(1);
14861                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
14862                                        {
14863                                        setState(1810);
14864                                        switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
14865                                        case 1:
14866                                                {
14867                                                setState(1806);
14868                                                match(WS);
14869                                                }
14870                                                break;
14871                                        case 2:
14872                                                {
14873                                                setState(1807);
14874                                                match(NEWLINE);
14875                                                }
14876                                                break;
14877                                        case 3:
14878                                                {
14879                                                setState(1808);
14880                                                match(LEADING_ASTERISK);
14881                                                }
14882                                                break;
14883                                        case 4:
14884                                                {
14885                                                setState(1809);
14886                                                text();
14887                                                }
14888                                                break;
14889                                        }
14890                                        }
14891                                        setState(1814);
14892                                        _errHandler.sync(this);
14893                                        _la = _input.LA(1);
14894                                }
14895                                }
14896                                break;
14897                        case DOC_ROOT_LITERAL:
14898                                {
14899                                setState(1815);
14900                                match(DOC_ROOT_LITERAL);
14901                                setState(1819);
14902                                _errHandler.sync(this);
14903                                _la = _input.LA(1);
14904                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14905                                        {
14906                                        {
14907                                        setState(1816);
14908                                        _la = _input.LA(1);
14909                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14910                                        _errHandler.recoverInline(this);
14911                                        } else {
14912                                                consume();
14913                                        }
14914                                        }
14915                                        }
14916                                        setState(1821);
14917                                        _errHandler.sync(this);
14918                                        _la = _input.LA(1);
14919                                }
14920                                }
14921                                break;
14922                        case INHERIT_DOC_LITERAL:
14923                                {
14924                                setState(1822);
14925                                match(INHERIT_DOC_LITERAL);
14926                                setState(1826);
14927                                _errHandler.sync(this);
14928                                _la = _input.LA(1);
14929                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14930                                        {
14931                                        {
14932                                        setState(1823);
14933                                        _la = _input.LA(1);
14934                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14935                                        _errHandler.recoverInline(this);
14936                                        } else {
14937                                                consume();
14938                                        }
14939                                        }
14940                                        }
14941                                        setState(1828);
14942                                        _errHandler.sync(this);
14943                                        _la = _input.LA(1);
14944                                }
14945                                }
14946                                break;
14947                        case LINK_LITERAL:
14948                                {
14949                                setState(1829);
14950                                match(LINK_LITERAL);
14951                                setState(1833);
14952                                _errHandler.sync(this);
14953                                _la = _input.LA(1);
14954                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14955                                        {
14956                                        {
14957                                        setState(1830);
14958                                        _la = _input.LA(1);
14959                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14960                                        _errHandler.recoverInline(this);
14961                                        } else {
14962                                                consume();
14963                                        }
14964                                        }
14965                                        }
14966                                        setState(1835);
14967                                        _errHandler.sync(this);
14968                                        _la = _input.LA(1);
14969                                }
14970                                setState(1836);
14971                                reference();
14972                                setState(1838);
14973                                switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
14974                                case 1:
14975                                        {
14976                                        setState(1837);
14977                                        description();
14978                                        }
14979                                        break;
14980                                }
14981                                }
14982                                break;
14983                        case LINKPLAIN_LITERAL:
14984                                {
14985                                setState(1840);
14986                                match(LINKPLAIN_LITERAL);
14987                                setState(1844);
14988                                _errHandler.sync(this);
14989                                _la = _input.LA(1);
14990                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14991                                        {
14992                                        {
14993                                        setState(1841);
14994                                        _la = _input.LA(1);
14995                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14996                                        _errHandler.recoverInline(this);
14997                                        } else {
14998                                                consume();
14999                                        }
15000                                        }
15001                                        }
15002                                        setState(1846);
15003                                        _errHandler.sync(this);
15004                                        _la = _input.LA(1);
15005                                }
15006                                setState(1847);
15007                                reference();
15008                                setState(1849);
15009                                switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
15010                                case 1:
15011                                        {
15012                                        setState(1848);
15013                                        description();
15014                                        }
15015                                        break;
15016                                }
15017                                }
15018                                break;
15019                        case LITERAL_LITERAL:
15020                                {
15021                                setState(1851);
15022                                match(LITERAL_LITERAL);
15023                                setState(1858);
15024                                _errHandler.sync(this);
15025                                _la = _input.LA(1);
15026                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15027                                        {
15028                                        setState(1856);
15029                                        switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
15030                                        case 1:
15031                                                {
15032                                                setState(1852);
15033                                                match(WS);
15034                                                }
15035                                                break;
15036                                        case 2:
15037                                                {
15038                                                setState(1853);
15039                                                match(NEWLINE);
15040                                                }
15041                                                break;
15042                                        case 3:
15043                                                {
15044                                                setState(1854);
15045                                                match(LEADING_ASTERISK);
15046                                                }
15047                                                break;
15048                                        case 4:
15049                                                {
15050                                                setState(1855);
15051                                                text();
15052                                                }
15053                                                break;
15054                                        }
15055                                        }
15056                                        setState(1860);
15057                                        _errHandler.sync(this);
15058                                        _la = _input.LA(1);
15059                                }
15060                                }
15061                                break;
15062                        case VALUE_LITERAL:
15063                                {
15064                                setState(1861);
15065                                match(VALUE_LITERAL);
15066                                setState(1865);
15067                                _errHandler.sync(this);
15068                                _la = _input.LA(1);
15069                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15070                                        {
15071                                        {
15072                                        setState(1862);
15073                                        _la = _input.LA(1);
15074                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15075                                        _errHandler.recoverInline(this);
15076                                        } else {
15077                                                consume();
15078                                        }
15079                                        }
15080                                        }
15081                                        setState(1867);
15082                                        _errHandler.sync(this);
15083                                        _la = _input.LA(1);
15084                                }
15085                                setState(1869);
15086                                _la = _input.LA(1);
15087                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) {
15088                                        {
15089                                        setState(1868);
15090                                        reference();
15091                                        }
15092                                }
15093
15094                                }
15095                                break;
15096                        case CUSTOM_NAME:
15097                                {
15098                                setState(1871);
15099                                match(CUSTOM_NAME);
15100                                setState(1873); 
15101                                _errHandler.sync(this);
15102                                _alt = 1;
15103                                do {
15104                                        switch (_alt) {
15105                                        case 1:
15106                                                {
15107                                                {
15108                                                setState(1872);
15109                                                _la = _input.LA(1);
15110                                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15111                                                _errHandler.recoverInline(this);
15112                                                } else {
15113                                                        consume();
15114                                                }
15115                                                }
15116                                                }
15117                                                break;
15118                                        default:
15119                                                throw new NoViableAltException(this);
15120                                        }
15121                                        setState(1875); 
15122                                        _errHandler.sync(this);
15123                                        _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15124                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15125                                setState(1878);
15126                                switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
15127                                case 1:
15128                                        {
15129                                        setState(1877);
15130                                        description();
15131                                        }
15132                                        break;
15133                                }
15134                                }
15135                                break;
15136                        default:
15137                                throw new NoViableAltException(this);
15138                        }
15139                        setState(1882);
15140                        match(JAVADOC_INLINE_TAG_END);
15141                        }
15142                }
15143                catch (RecognitionException re) {
15144                        _localctx.exception = re;
15145                        _errHandler.reportError(this, re);
15146                        _errHandler.recover(this, re);
15147                }
15148                finally {
15149                        exitRule();
15150                }
15151                return _localctx;
15152        }
15153
15154        public static class HtmlCommentContext extends ParserRuleContext {
15155                public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); }
15156                public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); }
15157                public List<TextContext> text() {
15158                        return getRuleContexts(TextContext.class);
15159                }
15160                public TextContext text(int i) {
15161                        return getRuleContext(TextContext.class,i);
15162                }
15163                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15164                public TerminalNode NEWLINE(int i) {
15165                        return getToken(JavadocParser.NEWLINE, i);
15166                }
15167                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15168                public TerminalNode LEADING_ASTERISK(int i) {
15169                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15170                }
15171                public HtmlCommentContext(ParserRuleContext parent, int invokingState) {
15172                        super(parent, invokingState);
15173                }
15174                @Override public int getRuleIndex() { return RULE_htmlComment; }
15175                @Override
15176                public void enterRule(ParseTreeListener listener) {
15177                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this);
15178                }
15179                @Override
15180                public void exitRule(ParseTreeListener listener) {
15181                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this);
15182                }
15183                @Override
15184                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15185                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this);
15186                        else return visitor.visitChildren(this);
15187                }
15188        }
15189
15190        public final HtmlCommentContext htmlComment() throws RecognitionException {
15191                HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState());
15192                enterRule(_localctx, 146, RULE_htmlComment);
15193                int _la;
15194                try {
15195                        enterOuterAlt(_localctx, 1);
15196                        {
15197                        setState(1884);
15198                        match(HTML_COMMENT_START);
15199                        setState(1890);
15200                        _errHandler.sync(this);
15201                        _la = _input.LA(1);
15202                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15203                                {
15204                                setState(1888);
15205                                switch (_input.LA(1)) {
15206                                case WS:
15207                                case CHAR:
15208                                        {
15209                                        setState(1885);
15210                                        text();
15211                                        }
15212                                        break;
15213                                case NEWLINE:
15214                                        {
15215                                        setState(1886);
15216                                        match(NEWLINE);
15217                                        }
15218                                        break;
15219                                case LEADING_ASTERISK:
15220                                        {
15221                                        setState(1887);
15222                                        match(LEADING_ASTERISK);
15223                                        }
15224                                        break;
15225                                default:
15226                                        throw new NoViableAltException(this);
15227                                }
15228                                }
15229                                setState(1892);
15230                                _errHandler.sync(this);
15231                                _la = _input.LA(1);
15232                        }
15233                        setState(1893);
15234                        match(HTML_COMMENT_END);
15235                        }
15236                }
15237                catch (RecognitionException re) {
15238                        _localctx.exception = re;
15239                        _errHandler.reportError(this, re);
15240                        _errHandler.recover(this, re);
15241                }
15242                finally {
15243                        exitRule();
15244                }
15245                return _localctx;
15246        }
15247
15248        public static class TextContext extends ParserRuleContext {
15249                public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); }
15250                public TerminalNode CHAR(int i) {
15251                        return getToken(JavadocParser.CHAR, i);
15252                }
15253                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15254                public TerminalNode WS(int i) {
15255                        return getToken(JavadocParser.WS, i);
15256                }
15257                public TextContext(ParserRuleContext parent, int invokingState) {
15258                        super(parent, invokingState);
15259                }
15260                @Override public int getRuleIndex() { return RULE_text; }
15261                @Override
15262                public void enterRule(ParseTreeListener listener) {
15263                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this);
15264                }
15265                @Override
15266                public void exitRule(ParseTreeListener listener) {
15267                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this);
15268                }
15269                @Override
15270                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15271                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this);
15272                        else return visitor.visitChildren(this);
15273                }
15274        }
15275
15276        public final TextContext text() throws RecognitionException {
15277                TextContext _localctx = new TextContext(_ctx, getState());
15278                enterRule(_localctx, 148, RULE_text);
15279                int _la;
15280                try {
15281                        int _alt;
15282                        enterOuterAlt(_localctx, 1);
15283                        {
15284                        setState(1896); 
15285                        _errHandler.sync(this);
15286                        _alt = 1;
15287                        do {
15288                                switch (_alt) {
15289                                case 1:
15290                                        {
15291                                        {
15292                                        setState(1895);
15293                                        _la = _input.LA(1);
15294                                        if ( !(_la==WS || _la==CHAR) ) {
15295                                        _errHandler.recoverInline(this);
15296                                        } else {
15297                                                consume();
15298                                        }
15299                                        }
15300                                        }
15301                                        break;
15302                                default:
15303                                        throw new NoViableAltException(this);
15304                                }
15305                                setState(1898); 
15306                                _errHandler.sync(this);
15307                                _alt = getInterpreter().adaptivePredict(_input,194,_ctx);
15308                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15309                        }
15310                }
15311                catch (RecognitionException re) {
15312                        _localctx.exception = re;
15313                        _errHandler.reportError(this, re);
15314                        _errHandler.recover(this, re);
15315                }
15316                finally {
15317                        exitRule();
15318                }
15319                return _localctx;
15320        }
15321
15322        public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
15323                switch (ruleIndex) {
15324                case 0:
15325                        return javadoc_sempred((JavadocContext)_localctx, predIndex);
15326                case 5:
15327                        return htmlTag_sempred((HtmlTagContext)_localctx, predIndex);
15328                case 8:
15329                        return paragraph_sempred((ParagraphContext)_localctx, predIndex);
15330                case 11:
15331                        return li_sempred((LiContext)_localctx, predIndex);
15332                case 14:
15333                        return tr_sempred((TrContext)_localctx, predIndex);
15334                case 17:
15335                        return td_sempred((TdContext)_localctx, predIndex);
15336                case 20:
15337                        return th_sempred((ThContext)_localctx, predIndex);
15338                case 23:
15339                        return body_sempred((BodyContext)_localctx, predIndex);
15340                case 26:
15341                        return colgroup_sempred((ColgroupContext)_localctx, predIndex);
15342                case 29:
15343                        return dd_sempred((DdContext)_localctx, predIndex);
15344                case 32:
15345                        return dt_sempred((DtContext)_localctx, predIndex);
15346                case 35:
15347                        return head_sempred((HeadContext)_localctx, predIndex);
15348                case 38:
15349                        return html_sempred((HtmlContext)_localctx, predIndex);
15350                case 41:
15351                        return option_sempred((OptionContext)_localctx, predIndex);
15352                case 44:
15353                        return tbody_sempred((TbodyContext)_localctx, predIndex);
15354                case 47:
15355                        return tfoot_sempred((TfootContext)_localctx, predIndex);
15356                case 50:
15357                        return thead_sempred((TheadContext)_localctx, predIndex);
15358                case 68:
15359                        return description_sempred((DescriptionContext)_localctx, predIndex);
15360                }
15361                return true;
15362        }
15363        private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) {
15364                switch (predIndex) {
15365                case 0:
15366                        return !isNextJavadocTag();
15367                }
15368                return true;
15369        }
15370        private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) {
15371                switch (predIndex) {
15372                case 1:
15373                        return !isNextJavadocTag();
15374                case 2:
15375                        return !isNextJavadocTag();
15376                }
15377                return true;
15378        }
15379        private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) {
15380                switch (predIndex) {
15381                case 3:
15382                        return !isNextJavadocTag();
15383                }
15384                return true;
15385        }
15386        private boolean li_sempred(LiContext _localctx, int predIndex) {
15387                switch (predIndex) {
15388                case 4:
15389                        return !isNextJavadocTag();
15390                }
15391                return true;
15392        }
15393        private boolean tr_sempred(TrContext _localctx, int predIndex) {
15394                switch (predIndex) {
15395                case 5:
15396                        return !isNextJavadocTag();
15397                }
15398                return true;
15399        }
15400        private boolean td_sempred(TdContext _localctx, int predIndex) {
15401                switch (predIndex) {
15402                case 6:
15403                        return !isNextJavadocTag();
15404                }
15405                return true;
15406        }
15407        private boolean th_sempred(ThContext _localctx, int predIndex) {
15408                switch (predIndex) {
15409                case 7:
15410                        return !isNextJavadocTag();
15411                }
15412                return true;
15413        }
15414        private boolean body_sempred(BodyContext _localctx, int predIndex) {
15415                switch (predIndex) {
15416                case 8:
15417                        return !isNextJavadocTag();
15418                }
15419                return true;
15420        }
15421        private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) {
15422                switch (predIndex) {
15423                case 9:
15424                        return !isNextJavadocTag();
15425                }
15426                return true;
15427        }
15428        private boolean dd_sempred(DdContext _localctx, int predIndex) {
15429                switch (predIndex) {
15430                case 10:
15431                        return !isNextJavadocTag();
15432                }
15433                return true;
15434        }
15435        private boolean dt_sempred(DtContext _localctx, int predIndex) {
15436                switch (predIndex) {
15437                case 11:
15438                        return !isNextJavadocTag();
15439                }
15440                return true;
15441        }
15442        private boolean head_sempred(HeadContext _localctx, int predIndex) {
15443                switch (predIndex) {
15444                case 12:
15445                        return !isNextJavadocTag();
15446                }
15447                return true;
15448        }
15449        private boolean html_sempred(HtmlContext _localctx, int predIndex) {
15450                switch (predIndex) {
15451                case 13:
15452                        return !isNextJavadocTag();
15453                }
15454                return true;
15455        }
15456        private boolean option_sempred(OptionContext _localctx, int predIndex) {
15457                switch (predIndex) {
15458                case 14:
15459                        return !isNextJavadocTag();
15460                }
15461                return true;
15462        }
15463        private boolean tbody_sempred(TbodyContext _localctx, int predIndex) {
15464                switch (predIndex) {
15465                case 15:
15466                        return !isNextJavadocTag();
15467                }
15468                return true;
15469        }
15470        private boolean tfoot_sempred(TfootContext _localctx, int predIndex) {
15471                switch (predIndex) {
15472                case 16:
15473                        return !isNextJavadocTag();
15474                }
15475                return true;
15476        }
15477        private boolean thead_sempred(TheadContext _localctx, int predIndex) {
15478                switch (predIndex) {
15479                case 17:
15480                        return !isNextJavadocTag();
15481                }
15482                return true;
15483        }
15484        private boolean description_sempred(DescriptionContext _localctx, int predIndex) {
15485                switch (predIndex) {
15486                case 18:
15487                        return !isNextJavadocTag();
15488                }
15489                return true;
15490        }
15491
15492        public static final String _serializedATN =
15493                "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u076f\4\2\t\2\4"+
15494                "\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"+
15495                "\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"+
15496                "\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"+
15497                "\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!"+
15498                "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
15499                ",\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"+
15500                "\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="+
15501                "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
15502                "\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"+
15503                "\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"+
15504                "\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"+
15505                "\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"+
15506                "\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"+
15507                "\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"+
15508                "\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"+
15509                "\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"+
15510                "\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"+
15511                "\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"+
15512                "\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"+
15513                "\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"+
15514                "\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"+
15515                "\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"+
15516                "\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"+
15517                "\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"+
15518                "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+
15519                "\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"+
15520                "\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"+
15521                "\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"+
15522                "\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"+
15523                "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+
15524                "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+
15525                "\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"+
15526                "\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"+
15527                "\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"+
15528                "\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"+
15529                "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+
15530                "\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"+
15531                "\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"+
15532                "\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"+
15533                "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+
15534                "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+
15535                "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+
15536                "\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"+
15537                "\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"+
15538                "\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"+
15539                "\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"+
15540                "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+
15541                "\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"+
15542                "\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"+
15543                "\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"+
15544                "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+
15545                "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+
15546                "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+
15547                "\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"+
15548                "\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"+
15549                "\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"+
15550                "\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"+
15551                "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+
15552                "\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"+
15553                "\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"+
15554                "\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"+
15555                "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+
15556                " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+
15557                "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
15558                "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
15559                "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+
15560                "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+
15561                "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15562                "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15563                "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+
15564                "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+
15565                "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15566                "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15567                "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+
15568                ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+
15569                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+
15570                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+
15571                "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+
15572                "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15573                "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15574                "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+
15575                "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+
15576                "\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"+
15577                "\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"+
15578                "\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"+
15579                "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+
15580                "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+
15581                "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+
15582                "\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"+
15583                "\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"+
15584                "\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"+
15585                "\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"+
15586                "\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"+
15587                "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+
15588                "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+
15589                "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+
15590                "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+
15591                "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+
15592                "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+
15593                "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+
15594                "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+
15595                "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+
15596                "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+
15597                "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+
15598                "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+
15599                "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+
15600                "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+
15601                "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+
15602                "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+
15603                "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+
15604                "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+
15605                "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+
15606                "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+
15607                "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+
15608                "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+
15609                "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+
15610                "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+
15611                "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+
15612                "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+
15613                "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+
15614                "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+
15615                "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+
15616                "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+
15617                "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+
15618                "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+
15619                "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+
15620                "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+
15621                "J\u0750\nJ\3J\3J\6J\u0754\nJ\rJ\16J\u0755\3J\5J\u0759\nJ\5J\u075b\nJ\3"+
15622                "J\3J\3K\3K\3K\3K\7K\u0763\nK\fK\16K\u0766\13K\3K\3K\3L\6L\u076b\nL\rL"+
15623                "\16L\u076c\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+
15624                "\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+
15625                "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6\6\b\b"+
15626                "\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\3\2\30"+
15627                "\31\4\2\6\6\32\32\u0a86\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7\3\2\2"+
15628                "\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2\2\2\20"+
15629                "\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2\2\30\u0191"+
15630                "\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2 \u0203\3\2"+
15631                "\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3\2\2\2*\u0260"+
15632                "\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62\u02d2\3\2\2"+
15633                "\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324\3\2\2\2<\u032f"+
15634                "\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D\u03a1\3\2\2\2F"+
15635                "\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2\2\2N\u03fe\3\2"+
15636                "\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470\3\2\2\2X\u047d"+
15637                "\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2`\u04cd\3\2\2\2"+
15638                "b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3\2\2\2j\u0550\3"+
15639                "\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584\3\2\2\2t\u0591"+
15640                "\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|\u05c5\3\2\2\2~"+
15641                "\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2\u0084\u05f9\3\2"+
15642                "\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616\3\2\2\2\u008c"+
15643                "\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092\u070e\3\2"+
15644                "\2\2\u0094\u075e\3\2\2\2\u0096\u076a\3\2\2\2\u0098\u00a1\5\4\3\2\u0099"+
15645                "\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c\u00a1"+
15646                "\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1\5\u0092"+
15647                "J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2\2\u00a0"+
15648                "\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2"+
15649                "\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
15650                "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+
15651                "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+
15652                "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+
15653                "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+
15654                "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
15655                "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+
15656                "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+
15657                "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+
15658                "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+
15659                "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+
15660                "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+
15661                "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+
15662                "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+
15663                "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+
15664                "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+
15665                "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+
15666                "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+
15667                "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+
15668                "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+
15669                "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+
15670                "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+
15671                "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+
15672                "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+
15673                "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+
15674                "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+
15675                "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+
15676                "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+
15677                "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+
15678                "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+
15679                "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+
15680                "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+
15681                "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+
15682                "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+
15683                "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+
15684                "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+
15685                "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+
15686                "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+
15687                "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+
15688                "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+
15689                "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
15690                "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+
15691                "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+
15692                "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+
15693                "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+
15694                "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+
15695                "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+
15696                "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+
15697                "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+
15698                "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+
15699                "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+
15700                "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+
15701                "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+
15702                "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
15703                "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+
15704                "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+
15705                "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+
15706                "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+
15707                "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+
15708                "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+
15709                "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+
15710                "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+
15711                "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+
15712                "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+
15713                "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+
15714                "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
15715                "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+
15716                "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+
15717                "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+
15718                "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+
15719                "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+
15720                "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+
15721                "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+
15722                "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+
15723                "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+
15724                "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+
15725                "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+
15726                "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+
15727                "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+
15728                "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+
15729                "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+
15730                "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+
15731                "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+
15732                "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+
15733                "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+
15734                "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+
15735                "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+
15736                "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+
15737                "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
15738                "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+
15739                "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+
15740                "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+
15741                "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+
15742                "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+
15743                "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+
15744                "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+
15745                "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
15746                "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+
15747                "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+
15748                "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+
15749                "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+
15750                "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+
15751                "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+
15752                "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+
15753                "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+
15754                "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+
15755                "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+
15756                "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+
15757                "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+
15758                "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+
15759                "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+
15760                "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+
15761                "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+
15762                "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+
15763                "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+
15764                "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+
15765                "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+
15766                "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+
15767                "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+
15768                "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+
15769                "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+
15770                "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+
15771                "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+
15772                "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+
15773                "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+
15774                "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+
15775                "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+
15776                "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+
15777                "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+
15778                "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+
15779                "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
15780                "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
15781                "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+
15782                "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+
15783                "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+
15784                "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+
15785                "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+
15786                "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+
15787                "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+
15788                "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+
15789                "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+
15790                "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+
15791                "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+
15792                "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+
15793                "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+
15794                "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+
15795                "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+
15796                "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+
15797                "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+
15798                "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+
15799                "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+
15800                "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+
15801                "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+
15802                "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+
15803                "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+
15804                "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+
15805                "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+
15806                "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+
15807                "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+
15808                "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+
15809                "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+
15810                "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+
15811                "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+
15812                "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+
15813                "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+
15814                "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+
15815                "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+
15816                "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+
15817                "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+
15818                "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+
15819                "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+
15820                "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+
15821                "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+
15822                "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+
15823                "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+
15824                "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+
15825                "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+
15826                "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+
15827                "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+
15828                "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+
15829                "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+
15830                "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+
15831                "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+
15832                "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+
15833                "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+
15834                "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+
15835                "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+
15836                "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+
15837                "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+
15838                "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
15839                "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+
15840                "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+
15841                "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+
15842                "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+
15843                "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+
15844                "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+
15845                "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+
15846                "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+
15847                "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+
15848                "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+
15849                "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+
15850                "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+
15851                "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+
15852                "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+
15853                "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+
15854                "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+
15855                "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+
15856                "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+
15857                "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+
15858                "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+
15859                "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+
15860                "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+
15861                "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+
15862                "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+
15863                "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+
15864                "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
15865                "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+
15866                "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+
15867                "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+
15868                "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+
15869                "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+
15870                "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+
15871                "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+
15872                "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+
15873                "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+
15874                "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+
15875                "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+
15876                "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+
15877                "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+
15878                "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+
15879                "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+
15880                "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+
15881                "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+
15882                ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+
15883                "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+
15884                "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+
15885                "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+
15886                "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+
15887                "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+
15888                "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+
15889                "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+
15890                "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+
15891                "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+
15892                "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+
15893                "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+
15894                "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+
15895                "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+
15896                "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+
15897                "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+
15898                "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+
15899                "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+
15900                "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+
15901                "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+
15902                "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+
15903                "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+
15904                "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+
15905                "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+
15906                "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+
15907                "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+
15908                "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+
15909                "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+
15910                "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+
15911                "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+
15912                "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+
15913                "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+
15914                "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+
15915                "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+
15916                "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+
15917                "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+
15918                "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+
15919                "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+
15920                "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+
15921                "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+
15922                "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+
15923                "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+
15924                "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+
15925                "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+
15926                "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
15927                "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+
15928                "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+
15929                "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+
15930                "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+
15931                "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+
15932                "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+
15933                "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+
15934                "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+
15935                "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+
15936                ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+
15937                "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+
15938                "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+
15939                "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+
15940                "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+
15941                "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+
15942                "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+
15943                "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+
15944                "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+
15945                "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+
15946                "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+
15947                "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+
15948                "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+
15949                "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+
15950                "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+
15951                "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+
15952                "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+
15953                "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+
15954                "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+
15955                "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+
15956                "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+
15957                "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+
15958                "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+
15959                "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+
15960                "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+
15961                "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+
15962                "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
15963                "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+
15964                "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+
15965                "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+
15966                "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+
15967                "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+
15968                "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+
15969                "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+
15970                "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+
15971                "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+
15972                "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+
15973                "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+
15974                "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+
15975                "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+
15976                "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+
15977                "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+
15978                "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+
15979                "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+
15980                "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+
15981                "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+
15982                "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+
15983                "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+
15984                "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+
15985                "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+
15986                "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+
15987                "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+
15988                "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+
15989                "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+
15990                "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+
15991                "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+
15992                "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+
15993                "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+
15994                "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+
15995                "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+
15996                "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+
15997                "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+
15998                "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+
15999                "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+
16000                "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+
16001                "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+
16002                "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+
16003                "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+
16004                "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+
16005                "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+
16006                "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+
16007                "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+
16008                "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+
16009                "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+
16010                "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+
16011                "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+
16012                "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+
16013                "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+
16014                "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+
16015                "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+
16016                "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+
16017                "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+
16018                "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+
16019                "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+
16020                "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+
16021                "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+
16022                "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+
16023                "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
16024                "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+
16025                "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+
16026                "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+
16027                "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+
16028                "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+
16029                "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+
16030                "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+
16031                "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+
16032                "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+
16033                "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+
16034                "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+
16035                "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+
16036                "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+
16037                "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+
16038                "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+
16039                "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+
16040                "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+
16041                "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+
16042                "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+
16043                "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+
16044                "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+
16045                "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+
16046                "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+
16047                "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+
16048                "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+
16049                "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+
16050                "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+
16051                "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+
16052                "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+
16053                "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+
16054                "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+
16055                "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+
16056                "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+
16057                "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+
16058                "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+
16059                "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+
16060                "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+
16061                "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+
16062                "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+
16063                "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+
16064                "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+
16065                "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+
16066                "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+
16067                "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+
16068                "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+
16069                "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+
16070                "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+
16071                "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+
16072                "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+
16073                "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+
16074                "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+
16075                "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+
16076                "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+
16077                "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+
16078                "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+
16079                "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+
16080                "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+
16081                "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+
16082                "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+
16083                "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+
16084                "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+
16085                "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+
16086                "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+
16087                "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+
16088                "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+
16089                "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+
16090                "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+
16091                "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+
16092                "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+
16093                "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+
16094                "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+
16095                "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+
16096                "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+
16097                "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+
16098                "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+
16099                "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+
16100                "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+
16101                "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+
16102                "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+
16103                "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+
16104                "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+
16105                "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+
16106                "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+
16107                "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+
16108                "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+
16109                "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+
16110                "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+
16111                "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+
16112                "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+
16113                "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+
16114                "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+
16115                "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+
16116                "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+
16117                "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+
16118                "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+
16119                "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+
16120                "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+
16121                "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+
16122                "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+
16123                "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+
16124                "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+
16125                "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+
16126                "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+
16127                "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+
16128                "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+
16129                "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+
16130                "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+
16131                "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+
16132                "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+
16133                "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+
16134                "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+
16135                "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+
16136                "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+
16137                "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+
16138                "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+
16139                "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+
16140                "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+
16141                "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+
16142                "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+
16143                "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+
16144                "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+
16145                "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+
16146                "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+
16147                "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+
16148                "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+
16149                "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+
16150                "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+
16151                "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+
16152                "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+
16153                "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+
16154                "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+
16155                "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+
16156                "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+
16157                "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+
16158                "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+
16159                "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+
16160                "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+
16161                "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+
16162                "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+
16163                "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+
16164                "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+
16165                "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+
16166                "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+
16167                "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+
16168                "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+
16169                "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+
16170                "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+
16171                "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+
16172                "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+
16173                "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+
16174                "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
16175                "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+
16176                "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+
16177                "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+
16178                "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+
16179                "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+
16180                "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+
16181                "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+
16182                "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+
16183                "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+
16184                "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+
16185                "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+
16186                "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+
16187                "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+
16188                "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+
16189                "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+
16190                "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+
16191                "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+
16192                "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+
16193                "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+
16194                "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+
16195                "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+
16196                "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+
16197                "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+
16198                "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+
16199                "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+
16200                "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+
16201                "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+
16202                "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+
16203                "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+
16204                "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+
16205                "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+
16206                "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+
16207                "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+
16208                "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+
16209                "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+
16210                "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+
16211                "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+
16212                "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+
16213                "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+
16214                "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+
16215                "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+
16216                "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+
16217                "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+
16218                "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+
16219                "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+
16220                "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+
16221                "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+
16222                "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+
16223                "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+
16224                "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+
16225                "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+
16226                "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+
16227                "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+
16228                "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+
16229                "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+
16230                "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+
16231                "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+
16232                "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+
16233                "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+
16234                "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+
16235                "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+
16236                "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+
16237                "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+
16238                "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+
16239                "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+
16240                "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+
16241                "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+
16242                "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+
16243                "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
16244                "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+
16245                "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+
16246                "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+
16247                "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+
16248                "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+
16249                "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+
16250                "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+
16251                "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+
16252                "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+
16253                "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+
16254                "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+
16255                "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+
16256                "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+
16257                "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+
16258                "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+
16259                "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+
16260                "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+
16261                "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+
16262                "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+
16263                "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+
16264                "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+
16265                "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+
16266                "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+
16267                "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+
16268                "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+
16269                "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+
16270                "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+
16271                "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+
16272                "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+
16273                "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+
16274                "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+
16275                "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+
16276                "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+
16277                "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+
16278                "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+
16279                "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+
16280                "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+
16281                "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+
16282                "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+
16283                "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+
16284                "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+
16285                "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+
16286                "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+
16287                "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+
16288                "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+
16289                "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+
16290                "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+
16291                "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+
16292                "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+
16293                "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+
16294                "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+
16295                "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+
16296                "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+
16297                "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+
16298                "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+
16299                "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+
16300                "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+
16301                "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+
16302                "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+
16303                "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+
16304                "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+
16305                "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+
16306                "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
16307                "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+
16308                "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+
16309                "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+
16310                "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+
16311                "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+
16312                "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+
16313                "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+
16314                "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+
16315                "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+
16316                "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+
16317                "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+
16318                "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+
16319                "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+
16320                "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+
16321                "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+
16322                "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+
16323                "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+
16324                "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+
16325                "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+
16326                "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+
16327                "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+
16328                "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+
16329                "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+
16330                "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+
16331                "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+
16332                "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+
16333                "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+
16334                "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+
16335                "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+
16336                "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+
16337                "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+
16338                "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+
16339                "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+
16340                "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+
16341                "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+
16342                "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+
16343                "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+
16344                "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+
16345                "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+
16346                "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+
16347                "\u0091\3\2\2\2\u070e\u075a\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+
16348                "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+
16349                "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+
16350                "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+
16351                "\u075b\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+
16352                "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+
16353                "\u071e\3\2\2\2\u071e\u075b\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+
16354                "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+
16355                "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075b\3\2\2\2\u0726\u0724\3\2"+
16356                "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+
16357                "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+
16358                "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+
16359                "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075b\3\2\2\2\u0732\u0736"+
16360                "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+
16361                "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+
16362                "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+
16363                "\2\2\u073b\u073c\3\2\2\2\u073c\u075b\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+
16364                "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+
16365                "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+
16366                "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+
16367                "\2\2\u0745\u075b\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+
16368                "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+
16369                "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
16370                "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075b"+
16371                "\3\2\2\2\u0751\u0753\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+
16372                "\u0754\u0755\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0758"+
16373                "\3\2\2\2\u0757\u0759\5\u008aF\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2"+
16374                "\2\u0759\u075b\3\2\2\2\u075a\u070f\3\2\2\2\u075a\u0719\3\2\2\2\u075a\u0720"+
16375                "\3\2\2\2\u075a\u0727\3\2\2\2\u075a\u0732\3\2\2\2\u075a\u073d\3\2\2\2\u075a"+
16376                "\u0747\3\2\2\2\u075a\u0751\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u075d\7\26"+
16377                "\2\2\u075d\u0093\3\2\2\2\u075e\u0764\7\4\2\2\u075f\u0763\5\u0096L\2\u0760"+
16378                "\u0763\7\b\2\2\u0761\u0763\7\3\2\2\u0762\u075f\3\2\2\2\u0762\u0760\3\2"+
16379                "\2\2\u0762\u0761\3\2\2\2\u0763\u0766\3\2\2\2\u0764\u0762\3\2\2\2\u0764"+
16380                "\u0765\3\2\2\2\u0765\u0767\3\2\2\2\u0766\u0764\3\2\2\2\u0767\u0768\7]"+
16381                "\2\2\u0768\u0095\3\2\2\2\u0769\u076b\t\n\2\2\u076a\u0769\3\2\2\2\u076b"+
16382                "\u076c\3\2\2\2\u076c\u076a\3\2\2\2\u076c\u076d\3\2\2\2\u076d\u0097\3\2"+
16383                "\2\2\u00c5\u00a0\u00a2\u00a6\u00ab\u00b1\u00e5\u00ed\u00ef\u00fa\u0103"+
16384                "\u010a\u0110\u011b\u011d\u012b\u012d\u0132\u013a\u013c\u0147\u0172\u0174"+
16385                "\u017f\u0181\u018c\u01b7\u01b9\u01c4\u01c6\u01d1\u01fc\u01fe\u0209\u020b"+
16386                "\u0216\u0241\u0243\u024e\u0250\u025b\u0286\u0288\u0293\u0295\u02a0\u02cb"+
16387                "\u02cd\u02d8\u02da\u02e5\u0310\u0312\u031d\u031f\u032a\u0355\u0357\u0362"+
16388                "\u0364\u036f\u039a\u039c\u03a7\u03a9\u03b4\u03df\u03e1\u03ec\u03ee\u03f9"+
16389                "\u0424\u0426\u0431\u0433\u043e\u0469\u046b\u0476\u0478\u0483\u04ae\u04b0"+
16390                "\u04bb\u04bd\u04c8\u04f3\u04f5\u0500\u0502\u050d\u0538\u053a\u054e\u0556"+
16391                "\u0558\u0563\u0565\u0570\u0572\u057d\u057f\u058a\u058c\u0597\u0599\u05a4"+
16392                "\u05a6\u05b1\u05b3\u05be\u05c0\u05cb\u05cd\u05d8\u05da\u05e5\u05e7\u05f2"+
16393                "\u05f4\u05ff\u0601\u0616\u0618\u061e\u0622\u0625\u0628\u062d\u0630\u0633"+
16394                "\u0636\u0639\u063d\u063f\u0645\u064e\u0652\u0658\u065c\u0662\u0666\u066b"+
16395                "\u066f\u0675\u0679\u067e\u0682\u0688\u068c\u0692\u0696\u069a\u069c\u06a2"+
16396                "\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9"+
16397                "\u06df\u06e3\u06e9\u06ed\u06f2\u06f6\u06fc\u0700\u0706\u070a\u070c\u0714"+
16398                "\u0716\u071d\u0724\u072b\u0730\u0736\u073b\u0742\u0744\u074b\u074f\u0755"+
16399                "\u0758\u075a\u0762\u0764\u076c";
16400        public static final ATN _ATN =
16401                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
16402        static {
16403                _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
16404                for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
16405                        _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
16406                }
16407        }
16408}