001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.5.2
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.2", RuntimeMetaData.VERSION); }
015
016        protected static final DFA[] _decisionToDFA;
017        protected static final PredictionContextCache _sharedContextCache =
018                new PredictionContextCache();
019        public static final int
020                LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, OPEN=5, NEWLINE=6, 
021                AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 
022                RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 
023                SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 
024                JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 
025                LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 
026                STRING=27, PACKAGE=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 
027                LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 
028                Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 
029                DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 
030                LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, CLOSE=55, 
031                SLASH_CLOSE=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 
032                TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 
033                COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 
034                HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 
035                TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 
036                BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 
037                COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 
038                INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 
039                META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, HTML_TAG_NAME=87, Char11=88, 
040                ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91;
041        public static final int
042                RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 
043                RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 
044                RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 
045                RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 
046                RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 
047                RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 
048                RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 
049                RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 
050                RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 
051                RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 
052                RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 
053                RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 
054                RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 
055                RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 
056                RULE_baseTag = 54, RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 
057                RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 
058                RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 
059                RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 
060                RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 
061                RULE_htmlComment = 73, RULE_text = 74;
062        public static final String[] ruleNames = {
063                "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 
064                "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 
065                "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 
066                "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 
067                "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 
068                "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 
069                "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 
070                "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 
071                "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 
072                "singletonTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", 
073                "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 
074                "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 
075                "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text"
076        };
077
078        private static final String[] _LITERAL_NAMES = {
079                null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 
080                null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 
081                null, "'@version'", null, null, null, "'include'", "'exclude'", null, 
082                null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 
083                "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 
084                "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 
085                "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 
086                null, null, null, null, null, null, null, null, null, null, null, null, 
087                null, null, null, null, null, null, null, null, null, null, "'-->'"
088        };
089        private static final String[] _SYMBOLIC_NAMES = {
090                null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 
091                "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 
092                "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 
093                "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 
094                "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 
095                "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", 
096                "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 
097                "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 
098                "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 
099                "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 
100                "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "SLASH", "EQUALS", 
101                "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 
102                "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 
103                "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 
104                "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 
105                "BASE_HTML_TAG_NAME", "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 
106                "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 
107                "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 
108                "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END"
109        };
110        public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
111
112        /**
113         * @deprecated Use {@link #VOCABULARY} instead.
114         */
115        @Deprecated
116        public static final String[] tokenNames;
117        static {
118                tokenNames = new String[_SYMBOLIC_NAMES.length];
119                for (int i = 0; i < tokenNames.length; i++) {
120                        tokenNames[i] = VOCABULARY.getLiteralName(i);
121                        if (tokenNames[i] == null) {
122                                tokenNames[i] = VOCABULARY.getSymbolicName(i);
123                        }
124
125                        if (tokenNames[i] == null) {
126                                tokenNames[i] = "<INVALID>";
127                        }
128                }
129        }
130
131        @Override
132        @Deprecated
133        public String[] getTokenNames() {
134                return tokenNames;
135        }
136
137        @Override
138
139        public Vocabulary getVocabulary() {
140                return VOCABULARY;
141        }
142
143        @Override
144        public String getGrammarFileName() { return "JavadocParser.g4"; }
145
146        @Override
147        public String[] getRuleNames() { return ruleNames; }
148
149        @Override
150        public String getSerializedATN() { return _serializedATN; }
151
152        @Override
153        public ATN getATN() { return _ATN; }
154
155
156            boolean isNextJavadocTag() {
157                int token1 = _input.LA(2);
158                int token2 = _input.LA(3);
159                return isJavadocTag(token1)
160                    || (token1 == WS && isJavadocTag(token2));
161            }
162
163            boolean isJavadocTag(int type) {
164                switch(type) {
165                    case AUTHOR_LITERAL:
166                    case DEPRECATED_LITERAL:
167                    case EXCEPTION_LITERAL:
168                    case PARAM_LITERAL:
169                    case RETURN_LITERAL:
170                    case SEE_LITERAL:
171                    case SERIAL_LITERAL:
172                    case SERIAL_FIELD_LITERAL:
173                    case SERIAL_DATA_LITERAL:
174                    case SINCE_LITERAL:
175                    case THROWS_LITERAL:
176                    case VERSION_LITERAL:
177                    case CUSTOM_NAME:
178                        return true;
179                    default:
180                        return false;
181                }
182            }
183
184              boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) {
185                    String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
186                    String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
187                    System.out.println(openTag + " - " + closeTag);
188                    return openTag.equals(closeTag);
189              }
190
191        public JavadocParser(TokenStream input) {
192                super(input);
193                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
194        }
195
196        public static class JavadocContext extends ParserRuleContext {
197                public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
198                public List<HtmlElementContext> htmlElement() {
199                        return getRuleContexts(HtmlElementContext.class);
200                }
201                public HtmlElementContext htmlElement(int i) {
202                        return getRuleContext(HtmlElementContext.class,i);
203                }
204                public List<HtmlCommentContext> htmlComment() {
205                        return getRuleContexts(HtmlCommentContext.class);
206                }
207                public HtmlCommentContext htmlComment(int i) {
208                        return getRuleContext(HtmlCommentContext.class,i);
209                }
210                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
211                public TerminalNode CDATA(int i) {
212                        return getToken(JavadocParser.CDATA, i);
213                }
214                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
215                public TerminalNode NEWLINE(int i) {
216                        return getToken(JavadocParser.NEWLINE, i);
217                }
218                public List<TextContext> text() {
219                        return getRuleContexts(TextContext.class);
220                }
221                public TextContext text(int i) {
222                        return getRuleContext(TextContext.class,i);
223                }
224                public List<JavadocInlineTagContext> javadocInlineTag() {
225                        return getRuleContexts(JavadocInlineTagContext.class);
226                }
227                public JavadocInlineTagContext javadocInlineTag(int i) {
228                        return getRuleContext(JavadocInlineTagContext.class,i);
229                }
230                public List<JavadocTagContext> javadocTag() {
231                        return getRuleContexts(JavadocTagContext.class);
232                }
233                public JavadocTagContext javadocTag(int i) {
234                        return getRuleContext(JavadocTagContext.class,i);
235                }
236                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
237                public TerminalNode LEADING_ASTERISK(int i) {
238                        return getToken(JavadocParser.LEADING_ASTERISK, i);
239                }
240                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
241                public TerminalNode WS(int i) {
242                        return getToken(JavadocParser.WS, i);
243                }
244                public JavadocContext(ParserRuleContext parent, int invokingState) {
245                        super(parent, invokingState);
246                }
247                @Override public int getRuleIndex() { return RULE_javadoc; }
248                @Override
249                public void enterRule(ParseTreeListener listener) {
250                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this);
251                }
252                @Override
253                public void exitRule(ParseTreeListener listener) {
254                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this);
255                }
256                @Override
257                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
258                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this);
259                        else return visitor.visitChildren(this);
260                }
261        }
262
263        public final JavadocContext javadoc() throws RecognitionException {
264                JavadocContext _localctx = new JavadocContext(_ctx, getState());
265                enterRule(_localctx, 0, RULE_javadoc);
266                int _la;
267                try {
268                        int _alt;
269                        enterOuterAlt(_localctx, 1);
270                        {
271                        setState(160);
272                        _errHandler.sync(this);
273                        _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
274                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
275                                if ( _alt==1 ) {
276                                        {
277                                        setState(158);
278                                        _errHandler.sync(this);
279                                        switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
280                                        case 1:
281                                                {
282                                                setState(150);
283                                                htmlElement();
284                                                }
285                                                break;
286                                        case 2:
287                                                {
288                                                {
289                                                setState(151);
290                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
291                                                setState(152);
292                                                match(LEADING_ASTERISK);
293                                                }
294                                                }
295                                                break;
296                                        case 3:
297                                                {
298                                                setState(153);
299                                                htmlComment();
300                                                }
301                                                break;
302                                        case 4:
303                                                {
304                                                setState(154);
305                                                match(CDATA);
306                                                }
307                                                break;
308                                        case 5:
309                                                {
310                                                setState(155);
311                                                match(NEWLINE);
312                                                }
313                                                break;
314                                        case 6:
315                                                {
316                                                setState(156);
317                                                text();
318                                                }
319                                                break;
320                                        case 7:
321                                                {
322                                                setState(157);
323                                                javadocInlineTag();
324                                                }
325                                                break;
326                                        }
327                                        } 
328                                }
329                                setState(162);
330                                _errHandler.sync(this);
331                                _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
332                        }
333                        setState(175);
334                        _errHandler.sync(this);
335                        _la = _input.LA(1);
336                        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)) {
337                                {
338                                {
339                                setState(164);
340                                _la = _input.LA(1);
341                                if (_la==LEADING_ASTERISK) {
342                                        {
343                                        setState(163);
344                                        match(LEADING_ASTERISK);
345                                        }
346                                }
347
348                                setState(169);
349                                _errHandler.sync(this);
350                                _la = _input.LA(1);
351                                while (_la==WS) {
352                                        {
353                                        {
354                                        setState(166);
355                                        match(WS);
356                                        }
357                                        }
358                                        setState(171);
359                                        _errHandler.sync(this);
360                                        _la = _input.LA(1);
361                                }
362                                setState(172);
363                                javadocTag();
364                                }
365                                }
366                                setState(177);
367                                _errHandler.sync(this);
368                                _la = _input.LA(1);
369                        }
370                        setState(178);
371                        match(EOF);
372                        }
373                }
374                catch (RecognitionException re) {
375                        _localctx.exception = re;
376                        _errHandler.reportError(this, re);
377                        _errHandler.recover(this, re);
378                }
379                finally {
380                        exitRule();
381                }
382                return _localctx;
383        }
384
385        public static class HtmlElementContext extends ParserRuleContext {
386                public HtmlTagContext htmlTag() {
387                        return getRuleContext(HtmlTagContext.class,0);
388                }
389                public SingletonElementContext singletonElement() {
390                        return getRuleContext(SingletonElementContext.class,0);
391                }
392                public ParagraphContext paragraph() {
393                        return getRuleContext(ParagraphContext.class,0);
394                }
395                public LiContext li() {
396                        return getRuleContext(LiContext.class,0);
397                }
398                public TrContext tr() {
399                        return getRuleContext(TrContext.class,0);
400                }
401                public TdContext td() {
402                        return getRuleContext(TdContext.class,0);
403                }
404                public ThContext th() {
405                        return getRuleContext(ThContext.class,0);
406                }
407                public BodyContext body() {
408                        return getRuleContext(BodyContext.class,0);
409                }
410                public ColgroupContext colgroup() {
411                        return getRuleContext(ColgroupContext.class,0);
412                }
413                public DdContext dd() {
414                        return getRuleContext(DdContext.class,0);
415                }
416                public DtContext dt() {
417                        return getRuleContext(DtContext.class,0);
418                }
419                public HeadContext head() {
420                        return getRuleContext(HeadContext.class,0);
421                }
422                public HtmlContext html() {
423                        return getRuleContext(HtmlContext.class,0);
424                }
425                public OptionContext option() {
426                        return getRuleContext(OptionContext.class,0);
427                }
428                public TbodyContext tbody() {
429                        return getRuleContext(TbodyContext.class,0);
430                }
431                public TheadContext thead() {
432                        return getRuleContext(TheadContext.class,0);
433                }
434                public TfootContext tfoot() {
435                        return getRuleContext(TfootContext.class,0);
436                }
437                public PTagOpenContext pTagOpen() {
438                        return getRuleContext(PTagOpenContext.class,0);
439                }
440                public LiTagOpenContext liTagOpen() {
441                        return getRuleContext(LiTagOpenContext.class,0);
442                }
443                public TrTagOpenContext trTagOpen() {
444                        return getRuleContext(TrTagOpenContext.class,0);
445                }
446                public TdTagOpenContext tdTagOpen() {
447                        return getRuleContext(TdTagOpenContext.class,0);
448                }
449                public ThTagOpenContext thTagOpen() {
450                        return getRuleContext(ThTagOpenContext.class,0);
451                }
452                public BodyTagOpenContext bodyTagOpen() {
453                        return getRuleContext(BodyTagOpenContext.class,0);
454                }
455                public ColgroupTagOpenContext colgroupTagOpen() {
456                        return getRuleContext(ColgroupTagOpenContext.class,0);
457                }
458                public DdTagOpenContext ddTagOpen() {
459                        return getRuleContext(DdTagOpenContext.class,0);
460                }
461                public DtTagOpenContext dtTagOpen() {
462                        return getRuleContext(DtTagOpenContext.class,0);
463                }
464                public HeadTagOpenContext headTagOpen() {
465                        return getRuleContext(HeadTagOpenContext.class,0);
466                }
467                public HtmlTagOpenContext htmlTagOpen() {
468                        return getRuleContext(HtmlTagOpenContext.class,0);
469                }
470                public OptionTagOpenContext optionTagOpen() {
471                        return getRuleContext(OptionTagOpenContext.class,0);
472                }
473                public TbodyTagOpenContext tbodyTagOpen() {
474                        return getRuleContext(TbodyTagOpenContext.class,0);
475                }
476                public TheadTagOpenContext theadTagOpen() {
477                        return getRuleContext(TheadTagOpenContext.class,0);
478                }
479                public TfootTagOpenContext tfootTagOpen() {
480                        return getRuleContext(TfootTagOpenContext.class,0);
481                }
482                public PTagCloseContext pTagClose() {
483                        return getRuleContext(PTagCloseContext.class,0);
484                }
485                public LiTagCloseContext liTagClose() {
486                        return getRuleContext(LiTagCloseContext.class,0);
487                }
488                public TrTagCloseContext trTagClose() {
489                        return getRuleContext(TrTagCloseContext.class,0);
490                }
491                public TdTagCloseContext tdTagClose() {
492                        return getRuleContext(TdTagCloseContext.class,0);
493                }
494                public ThTagCloseContext thTagClose() {
495                        return getRuleContext(ThTagCloseContext.class,0);
496                }
497                public BodyTagCloseContext bodyTagClose() {
498                        return getRuleContext(BodyTagCloseContext.class,0);
499                }
500                public ColgroupTagCloseContext colgroupTagClose() {
501                        return getRuleContext(ColgroupTagCloseContext.class,0);
502                }
503                public DdTagCloseContext ddTagClose() {
504                        return getRuleContext(DdTagCloseContext.class,0);
505                }
506                public DtTagCloseContext dtTagClose() {
507                        return getRuleContext(DtTagCloseContext.class,0);
508                }
509                public HeadTagCloseContext headTagClose() {
510                        return getRuleContext(HeadTagCloseContext.class,0);
511                }
512                public HtmlTagCloseContext htmlTagClose() {
513                        return getRuleContext(HtmlTagCloseContext.class,0);
514                }
515                public OptionTagCloseContext optionTagClose() {
516                        return getRuleContext(OptionTagCloseContext.class,0);
517                }
518                public TbodyTagCloseContext tbodyTagClose() {
519                        return getRuleContext(TbodyTagCloseContext.class,0);
520                }
521                public TheadTagCloseContext theadTagClose() {
522                        return getRuleContext(TheadTagCloseContext.class,0);
523                }
524                public TfootTagCloseContext tfootTagClose() {
525                        return getRuleContext(TfootTagCloseContext.class,0);
526                }
527                public HtmlElementContext(ParserRuleContext parent, int invokingState) {
528                        super(parent, invokingState);
529                }
530                @Override public int getRuleIndex() { return RULE_htmlElement; }
531                @Override
532                public void enterRule(ParseTreeListener listener) {
533                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this);
534                }
535                @Override
536                public void exitRule(ParseTreeListener listener) {
537                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this);
538                }
539                @Override
540                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
541                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this);
542                        else return visitor.visitChildren(this);
543                }
544        }
545
546        public final HtmlElementContext htmlElement() throws RecognitionException {
547                HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
548                enterRule(_localctx, 2, RULE_htmlElement);
549                try {
550                        setState(227);
551                        _errHandler.sync(this);
552                        switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
553                        case 1:
554                                enterOuterAlt(_localctx, 1);
555                                {
556                                setState(180);
557                                htmlTag();
558                                }
559                                break;
560                        case 2:
561                                enterOuterAlt(_localctx, 2);
562                                {
563                                setState(181);
564                                singletonElement();
565                                }
566                                break;
567                        case 3:
568                                enterOuterAlt(_localctx, 3);
569                                {
570                                setState(182);
571                                paragraph();
572                                }
573                                break;
574                        case 4:
575                                enterOuterAlt(_localctx, 4);
576                                {
577                                setState(183);
578                                li();
579                                }
580                                break;
581                        case 5:
582                                enterOuterAlt(_localctx, 5);
583                                {
584                                setState(184);
585                                tr();
586                                }
587                                break;
588                        case 6:
589                                enterOuterAlt(_localctx, 6);
590                                {
591                                setState(185);
592                                td();
593                                }
594                                break;
595                        case 7:
596                                enterOuterAlt(_localctx, 7);
597                                {
598                                setState(186);
599                                th();
600                                }
601                                break;
602                        case 8:
603                                enterOuterAlt(_localctx, 8);
604                                {
605                                setState(187);
606                                body();
607                                }
608                                break;
609                        case 9:
610                                enterOuterAlt(_localctx, 9);
611                                {
612                                setState(188);
613                                colgroup();
614                                }
615                                break;
616                        case 10:
617                                enterOuterAlt(_localctx, 10);
618                                {
619                                setState(189);
620                                dd();
621                                }
622                                break;
623                        case 11:
624                                enterOuterAlt(_localctx, 11);
625                                {
626                                setState(190);
627                                dt();
628                                }
629                                break;
630                        case 12:
631                                enterOuterAlt(_localctx, 12);
632                                {
633                                setState(191);
634                                head();
635                                }
636                                break;
637                        case 13:
638                                enterOuterAlt(_localctx, 13);
639                                {
640                                setState(192);
641                                html();
642                                }
643                                break;
644                        case 14:
645                                enterOuterAlt(_localctx, 14);
646                                {
647                                setState(193);
648                                option();
649                                }
650                                break;
651                        case 15:
652                                enterOuterAlt(_localctx, 15);
653                                {
654                                setState(194);
655                                tbody();
656                                }
657                                break;
658                        case 16:
659                                enterOuterAlt(_localctx, 16);
660                                {
661                                setState(195);
662                                thead();
663                                }
664                                break;
665                        case 17:
666                                enterOuterAlt(_localctx, 17);
667                                {
668                                setState(196);
669                                tfoot();
670                                }
671                                break;
672                        case 18:
673                                enterOuterAlt(_localctx, 18);
674                                {
675                                setState(197);
676                                pTagOpen();
677                                }
678                                break;
679                        case 19:
680                                enterOuterAlt(_localctx, 19);
681                                {
682                                setState(198);
683                                liTagOpen();
684                                }
685                                break;
686                        case 20:
687                                enterOuterAlt(_localctx, 20);
688                                {
689                                setState(199);
690                                trTagOpen();
691                                }
692                                break;
693                        case 21:
694                                enterOuterAlt(_localctx, 21);
695                                {
696                                setState(200);
697                                tdTagOpen();
698                                }
699                                break;
700                        case 22:
701                                enterOuterAlt(_localctx, 22);
702                                {
703                                setState(201);
704                                thTagOpen();
705                                }
706                                break;
707                        case 23:
708                                enterOuterAlt(_localctx, 23);
709                                {
710                                setState(202);
711                                bodyTagOpen();
712                                }
713                                break;
714                        case 24:
715                                enterOuterAlt(_localctx, 24);
716                                {
717                                setState(203);
718                                colgroupTagOpen();
719                                }
720                                break;
721                        case 25:
722                                enterOuterAlt(_localctx, 25);
723                                {
724                                setState(204);
725                                ddTagOpen();
726                                }
727                                break;
728                        case 26:
729                                enterOuterAlt(_localctx, 26);
730                                {
731                                setState(205);
732                                dtTagOpen();
733                                }
734                                break;
735                        case 27:
736                                enterOuterAlt(_localctx, 27);
737                                {
738                                setState(206);
739                                headTagOpen();
740                                }
741                                break;
742                        case 28:
743                                enterOuterAlt(_localctx, 28);
744                                {
745                                setState(207);
746                                htmlTagOpen();
747                                }
748                                break;
749                        case 29:
750                                enterOuterAlt(_localctx, 29);
751                                {
752                                setState(208);
753                                optionTagOpen();
754                                }
755                                break;
756                        case 30:
757                                enterOuterAlt(_localctx, 30);
758                                {
759                                setState(209);
760                                tbodyTagOpen();
761                                }
762                                break;
763                        case 31:
764                                enterOuterAlt(_localctx, 31);
765                                {
766                                setState(210);
767                                theadTagOpen();
768                                }
769                                break;
770                        case 32:
771                                enterOuterAlt(_localctx, 32);
772                                {
773                                setState(211);
774                                tfootTagOpen();
775                                }
776                                break;
777                        case 33:
778                                enterOuterAlt(_localctx, 33);
779                                {
780                                setState(212);
781                                pTagClose();
782                                }
783                                break;
784                        case 34:
785                                enterOuterAlt(_localctx, 34);
786                                {
787                                setState(213);
788                                liTagClose();
789                                }
790                                break;
791                        case 35:
792                                enterOuterAlt(_localctx, 35);
793                                {
794                                setState(214);
795                                trTagClose();
796                                }
797                                break;
798                        case 36:
799                                enterOuterAlt(_localctx, 36);
800                                {
801                                setState(215);
802                                tdTagClose();
803                                }
804                                break;
805                        case 37:
806                                enterOuterAlt(_localctx, 37);
807                                {
808                                setState(216);
809                                thTagClose();
810                                }
811                                break;
812                        case 38:
813                                enterOuterAlt(_localctx, 38);
814                                {
815                                setState(217);
816                                bodyTagClose();
817                                }
818                                break;
819                        case 39:
820                                enterOuterAlt(_localctx, 39);
821                                {
822                                setState(218);
823                                colgroupTagClose();
824                                }
825                                break;
826                        case 40:
827                                enterOuterAlt(_localctx, 40);
828                                {
829                                setState(219);
830                                ddTagClose();
831                                }
832                                break;
833                        case 41:
834                                enterOuterAlt(_localctx, 41);
835                                {
836                                setState(220);
837                                dtTagClose();
838                                }
839                                break;
840                        case 42:
841                                enterOuterAlt(_localctx, 42);
842                                {
843                                setState(221);
844                                headTagClose();
845                                }
846                                break;
847                        case 43:
848                                enterOuterAlt(_localctx, 43);
849                                {
850                                setState(222);
851                                htmlTagClose();
852                                }
853                                break;
854                        case 44:
855                                enterOuterAlt(_localctx, 44);
856                                {
857                                setState(223);
858                                optionTagClose();
859                                }
860                                break;
861                        case 45:
862                                enterOuterAlt(_localctx, 45);
863                                {
864                                setState(224);
865                                tbodyTagClose();
866                                }
867                                break;
868                        case 46:
869                                enterOuterAlt(_localctx, 46);
870                                {
871                                setState(225);
872                                theadTagClose();
873                                }
874                                break;
875                        case 47:
876                                enterOuterAlt(_localctx, 47);
877                                {
878                                setState(226);
879                                tfootTagClose();
880                                }
881                                break;
882                        }
883                }
884                catch (RecognitionException re) {
885                        _localctx.exception = re;
886                        _errHandler.reportError(this, re);
887                        _errHandler.recover(this, re);
888                }
889                finally {
890                        exitRule();
891                }
892                return _localctx;
893        }
894
895        public static class HtmlElementOpenContext extends ParserRuleContext {
896                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
897                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
898                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
899                public List<AttributeContext> attribute() {
900                        return getRuleContexts(AttributeContext.class);
901                }
902                public AttributeContext attribute(int i) {
903                        return getRuleContext(AttributeContext.class,i);
904                }
905                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
906                public TerminalNode NEWLINE(int i) {
907                        return getToken(JavadocParser.NEWLINE, i);
908                }
909                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
910                public TerminalNode LEADING_ASTERISK(int i) {
911                        return getToken(JavadocParser.LEADING_ASTERISK, i);
912                }
913                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
914                public TerminalNode WS(int i) {
915                        return getToken(JavadocParser.WS, i);
916                }
917                public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) {
918                        super(parent, invokingState);
919                }
920                @Override public int getRuleIndex() { return RULE_htmlElementOpen; }
921                @Override
922                public void enterRule(ParseTreeListener listener) {
923                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this);
924                }
925                @Override
926                public void exitRule(ParseTreeListener listener) {
927                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this);
928                }
929                @Override
930                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
931                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this);
932                        else return visitor.visitChildren(this);
933                }
934        }
935
936        public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException {
937                HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState());
938                enterRule(_localctx, 4, RULE_htmlElementOpen);
939                int _la;
940                try {
941                        enterOuterAlt(_localctx, 1);
942                        {
943                        setState(229);
944                        match(OPEN);
945                        setState(230);
946                        match(HTML_TAG_NAME);
947                        setState(237);
948                        _errHandler.sync(this);
949                        _la = _input.LA(1);
950                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
951                                {
952                                setState(235);
953                                switch (_input.LA(1)) {
954                                case HTML_TAG_NAME:
955                                        {
956                                        setState(231);
957                                        attribute();
958                                        }
959                                        break;
960                                case NEWLINE:
961                                        {
962                                        setState(232);
963                                        match(NEWLINE);
964                                        }
965                                        break;
966                                case LEADING_ASTERISK:
967                                        {
968                                        setState(233);
969                                        match(LEADING_ASTERISK);
970                                        }
971                                        break;
972                                case WS:
973                                        {
974                                        setState(234);
975                                        match(WS);
976                                        }
977                                        break;
978                                default:
979                                        throw new NoViableAltException(this);
980                                }
981                                }
982                                setState(239);
983                                _errHandler.sync(this);
984                                _la = _input.LA(1);
985                        }
986                        setState(240);
987                        match(CLOSE);
988                        }
989                }
990                catch (RecognitionException re) {
991                        _localctx.exception = re;
992                        _errHandler.reportError(this, re);
993                        _errHandler.recover(this, re);
994                }
995                finally {
996                        exitRule();
997                }
998                return _localctx;
999        }
1000
1001        public static class HtmlElementCloseContext extends ParserRuleContext {
1002                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1003                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1004                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
1005                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1006                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1007                public TerminalNode NEWLINE(int i) {
1008                        return getToken(JavadocParser.NEWLINE, i);
1009                }
1010                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1011                public TerminalNode LEADING_ASTERISK(int i) {
1012                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1013                }
1014                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1015                public TerminalNode WS(int i) {
1016                        return getToken(JavadocParser.WS, i);
1017                }
1018                public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) {
1019                        super(parent, invokingState);
1020                }
1021                @Override public int getRuleIndex() { return RULE_htmlElementClose; }
1022                @Override
1023                public void enterRule(ParseTreeListener listener) {
1024                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this);
1025                }
1026                @Override
1027                public void exitRule(ParseTreeListener listener) {
1028                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this);
1029                }
1030                @Override
1031                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1032                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this);
1033                        else return visitor.visitChildren(this);
1034                }
1035        }
1036
1037        public final HtmlElementCloseContext htmlElementClose() throws RecognitionException {
1038                HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState());
1039                enterRule(_localctx, 6, RULE_htmlElementClose);
1040                int _la;
1041                try {
1042                        enterOuterAlt(_localctx, 1);
1043                        {
1044                        setState(242);
1045                        match(OPEN);
1046                        setState(243);
1047                        match(SLASH);
1048                        setState(244);
1049                        match(HTML_TAG_NAME);
1050                        setState(248);
1051                        _errHandler.sync(this);
1052                        _la = _input.LA(1);
1053                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1054                                {
1055                                {
1056                                setState(245);
1057                                _la = _input.LA(1);
1058                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1059                                _errHandler.recoverInline(this);
1060                                } else {
1061                                        consume();
1062                                }
1063                                }
1064                                }
1065                                setState(250);
1066                                _errHandler.sync(this);
1067                                _la = _input.LA(1);
1068                        }
1069                        setState(251);
1070                        match(CLOSE);
1071                        }
1072                }
1073                catch (RecognitionException re) {
1074                        _localctx.exception = re;
1075                        _errHandler.reportError(this, re);
1076                        _errHandler.recover(this, re);
1077                }
1078                finally {
1079                        exitRule();
1080                }
1081                return _localctx;
1082        }
1083
1084        public static class AttributeContext extends ParserRuleContext {
1085                public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
1086                public TerminalNode HTML_TAG_NAME(int i) {
1087                        return getToken(JavadocParser.HTML_TAG_NAME, i);
1088                }
1089                public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
1090                public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
1091                public TextContext text() {
1092                        return getRuleContext(TextContext.class,0);
1093                }
1094                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1095                public TerminalNode NEWLINE(int i) {
1096                        return getToken(JavadocParser.NEWLINE, i);
1097                }
1098                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1099                public TerminalNode LEADING_ASTERISK(int i) {
1100                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1101                }
1102                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1103                public TerminalNode WS(int i) {
1104                        return getToken(JavadocParser.WS, i);
1105                }
1106                public AttributeContext(ParserRuleContext parent, int invokingState) {
1107                        super(parent, invokingState);
1108                }
1109                @Override public int getRuleIndex() { return RULE_attribute; }
1110                @Override
1111                public void enterRule(ParseTreeListener listener) {
1112                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this);
1113                }
1114                @Override
1115                public void exitRule(ParseTreeListener listener) {
1116                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this);
1117                }
1118                @Override
1119                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1120                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this);
1121                        else return visitor.visitChildren(this);
1122                }
1123        }
1124
1125        public final AttributeContext attribute() throws RecognitionException {
1126                AttributeContext _localctx = new AttributeContext(_ctx, getState());
1127                enterRule(_localctx, 8, RULE_attribute);
1128                int _la;
1129                try {
1130                        int _alt;
1131                        enterOuterAlt(_localctx, 1);
1132                        {
1133                        setState(253);
1134                        match(HTML_TAG_NAME);
1135                        setState(257);
1136                        _errHandler.sync(this);
1137                        _la = _input.LA(1);
1138                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1139                                {
1140                                {
1141                                setState(254);
1142                                _la = _input.LA(1);
1143                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1144                                _errHandler.recoverInline(this);
1145                                } else {
1146                                        consume();
1147                                }
1148                                }
1149                                }
1150                                setState(259);
1151                                _errHandler.sync(this);
1152                                _la = _input.LA(1);
1153                        }
1154                        setState(260);
1155                        match(EQUALS);
1156                        setState(264);
1157                        _errHandler.sync(this);
1158                        _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1159                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1160                                if ( _alt==1 ) {
1161                                        {
1162                                        {
1163                                        setState(261);
1164                                        _la = _input.LA(1);
1165                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1166                                        _errHandler.recoverInline(this);
1167                                        } else {
1168                                                consume();
1169                                        }
1170                                        }
1171                                        } 
1172                                }
1173                                setState(266);
1174                                _errHandler.sync(this);
1175                                _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1176                        }
1177                        setState(270);
1178                        switch (_input.LA(1)) {
1179                        case ATTR_VALUE:
1180                                {
1181                                setState(267);
1182                                match(ATTR_VALUE);
1183                                }
1184                                break;
1185                        case WS:
1186                        case CHAR:
1187                                {
1188                                setState(268);
1189                                text();
1190                                }
1191                                break;
1192                        case HTML_TAG_NAME:
1193                                {
1194                                setState(269);
1195                                match(HTML_TAG_NAME);
1196                                }
1197                                break;
1198                        default:
1199                                throw new NoViableAltException(this);
1200                        }
1201                        }
1202                }
1203                catch (RecognitionException re) {
1204                        _localctx.exception = re;
1205                        _errHandler.reportError(this, re);
1206                        _errHandler.recover(this, re);
1207                }
1208                finally {
1209                        exitRule();
1210                }
1211                return _localctx;
1212        }
1213
1214        public static class HtmlTagContext extends ParserRuleContext {
1215                public HtmlElementOpenContext htmlElementOpen;
1216                public HtmlElementOpenContext htmlElementOpen() {
1217                        return getRuleContext(HtmlElementOpenContext.class,0);
1218                }
1219                public HtmlElementCloseContext htmlElementClose() {
1220                        return getRuleContext(HtmlElementCloseContext.class,0);
1221                }
1222                public List<HtmlElementContext> htmlElement() {
1223                        return getRuleContexts(HtmlElementContext.class);
1224                }
1225                public HtmlElementContext htmlElement(int i) {
1226                        return getRuleContext(HtmlElementContext.class,i);
1227                }
1228                public List<HtmlCommentContext> htmlComment() {
1229                        return getRuleContexts(HtmlCommentContext.class);
1230                }
1231                public HtmlCommentContext htmlComment(int i) {
1232                        return getRuleContext(HtmlCommentContext.class,i);
1233                }
1234                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1235                public TerminalNode CDATA(int i) {
1236                        return getToken(JavadocParser.CDATA, i);
1237                }
1238                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1239                public TerminalNode NEWLINE(int i) {
1240                        return getToken(JavadocParser.NEWLINE, i);
1241                }
1242                public List<TextContext> text() {
1243                        return getRuleContexts(TextContext.class);
1244                }
1245                public TextContext text(int i) {
1246                        return getRuleContext(TextContext.class,i);
1247                }
1248                public List<JavadocInlineTagContext> javadocInlineTag() {
1249                        return getRuleContexts(JavadocInlineTagContext.class);
1250                }
1251                public JavadocInlineTagContext javadocInlineTag(int i) {
1252                        return getRuleContext(JavadocInlineTagContext.class,i);
1253                }
1254                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1255                public TerminalNode LEADING_ASTERISK(int i) {
1256                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1257                }
1258                public HtmlTagContext(ParserRuleContext parent, int invokingState) {
1259                        super(parent, invokingState);
1260                }
1261                @Override public int getRuleIndex() { return RULE_htmlTag; }
1262                @Override
1263                public void enterRule(ParseTreeListener listener) {
1264                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this);
1265                }
1266                @Override
1267                public void exitRule(ParseTreeListener listener) {
1268                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this);
1269                }
1270                @Override
1271                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1272                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this);
1273                        else return visitor.visitChildren(this);
1274                }
1275        }
1276
1277        public final HtmlTagContext htmlTag() throws RecognitionException {
1278                HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1279                enterRule(_localctx, 10, RULE_htmlTag);
1280                try {
1281                        int _alt;
1282                        setState(304);
1283                        _errHandler.sync(this);
1284                        switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
1285                        case 1:
1286                                enterOuterAlt(_localctx, 1);
1287                                {
1288                                setState(272);
1289                                htmlElementOpen();
1290                                setState(283);
1291                                _errHandler.sync(this);
1292                                _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1293                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1294                                        if ( _alt==1 ) {
1295                                                {
1296                                                setState(281);
1297                                                _errHandler.sync(this);
1298                                                switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1299                                                case 1:
1300                                                        {
1301                                                        setState(273);
1302                                                        htmlElement();
1303                                                        }
1304                                                        break;
1305                                                case 2:
1306                                                        {
1307                                                        {
1308                                                        setState(274);
1309                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1310                                                        setState(275);
1311                                                        match(LEADING_ASTERISK);
1312                                                        }
1313                                                        }
1314                                                        break;
1315                                                case 3:
1316                                                        {
1317                                                        setState(276);
1318                                                        htmlComment();
1319                                                        }
1320                                                        break;
1321                                                case 4:
1322                                                        {
1323                                                        setState(277);
1324                                                        match(CDATA);
1325                                                        }
1326                                                        break;
1327                                                case 5:
1328                                                        {
1329                                                        setState(278);
1330                                                        match(NEWLINE);
1331                                                        }
1332                                                        break;
1333                                                case 6:
1334                                                        {
1335                                                        setState(279);
1336                                                        text();
1337                                                        }
1338                                                        break;
1339                                                case 7:
1340                                                        {
1341                                                        setState(280);
1342                                                        javadocInlineTag();
1343                                                        }
1344                                                        break;
1345                                                }
1346                                                } 
1347                                        }
1348                                        setState(285);
1349                                        _errHandler.sync(this);
1350                                        _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1351                                }
1352                                setState(286);
1353                                htmlElementClose();
1354                                }
1355                                break;
1356                        case 2:
1357                                enterOuterAlt(_localctx, 2);
1358                                {
1359                                setState(288);
1360                                ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen();
1361                                setState(299);
1362                                _errHandler.sync(this);
1363                                _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1364                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1365                                        if ( _alt==1 ) {
1366                                                {
1367                                                setState(297);
1368                                                _errHandler.sync(this);
1369                                                switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
1370                                                case 1:
1371                                                        {
1372                                                        setState(289);
1373                                                        htmlElement();
1374                                                        }
1375                                                        break;
1376                                                case 2:
1377                                                        {
1378                                                        {
1379                                                        setState(290);
1380                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1381                                                        setState(291);
1382                                                        match(LEADING_ASTERISK);
1383                                                        }
1384                                                        }
1385                                                        break;
1386                                                case 3:
1387                                                        {
1388                                                        setState(292);
1389                                                        htmlComment();
1390                                                        }
1391                                                        break;
1392                                                case 4:
1393                                                        {
1394                                                        setState(293);
1395                                                        match(CDATA);
1396                                                        }
1397                                                        break;
1398                                                case 5:
1399                                                        {
1400                                                        setState(294);
1401                                                        match(NEWLINE);
1402                                                        }
1403                                                        break;
1404                                                case 6:
1405                                                        {
1406                                                        setState(295);
1407                                                        text();
1408                                                        }
1409                                                        break;
1410                                                case 7:
1411                                                        {
1412                                                        setState(296);
1413                                                        javadocInlineTag();
1414                                                        }
1415                                                        break;
1416                                                }
1417                                                } 
1418                                        }
1419                                        setState(301);
1420                                        _errHandler.sync(this);
1421                                        _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1422                                }
1423                                notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol()
1424                                                                         , "javadoc.missed.html.close", null);
1425                                }
1426                                break;
1427                        }
1428                }
1429                catch (RecognitionException re) {
1430                        _localctx.exception = re;
1431                        _errHandler.reportError(this, re);
1432                        _errHandler.recover(this, re);
1433                }
1434                finally {
1435                        exitRule();
1436                }
1437                return _localctx;
1438        }
1439
1440        public static class PTagOpenContext extends ParserRuleContext {
1441                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1442                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1443                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1444                public List<AttributeContext> attribute() {
1445                        return getRuleContexts(AttributeContext.class);
1446                }
1447                public AttributeContext attribute(int i) {
1448                        return getRuleContext(AttributeContext.class,i);
1449                }
1450                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1451                public TerminalNode NEWLINE(int i) {
1452                        return getToken(JavadocParser.NEWLINE, i);
1453                }
1454                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1455                public TerminalNode LEADING_ASTERISK(int i) {
1456                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1457                }
1458                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1459                public TerminalNode WS(int i) {
1460                        return getToken(JavadocParser.WS, i);
1461                }
1462                public PTagOpenContext(ParserRuleContext parent, int invokingState) {
1463                        super(parent, invokingState);
1464                }
1465                @Override public int getRuleIndex() { return RULE_pTagOpen; }
1466                @Override
1467                public void enterRule(ParseTreeListener listener) {
1468                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this);
1469                }
1470                @Override
1471                public void exitRule(ParseTreeListener listener) {
1472                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this);
1473                }
1474                @Override
1475                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1476                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this);
1477                        else return visitor.visitChildren(this);
1478                }
1479        }
1480
1481        public final PTagOpenContext pTagOpen() throws RecognitionException {
1482                PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState());
1483                enterRule(_localctx, 12, RULE_pTagOpen);
1484                int _la;
1485                try {
1486                        enterOuterAlt(_localctx, 1);
1487                        {
1488                        setState(306);
1489                        match(OPEN);
1490                        setState(307);
1491                        match(P_HTML_TAG_NAME);
1492                        setState(314);
1493                        _errHandler.sync(this);
1494                        _la = _input.LA(1);
1495                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1496                                {
1497                                setState(312);
1498                                switch (_input.LA(1)) {
1499                                case HTML_TAG_NAME:
1500                                        {
1501                                        setState(308);
1502                                        attribute();
1503                                        }
1504                                        break;
1505                                case NEWLINE:
1506                                        {
1507                                        setState(309);
1508                                        match(NEWLINE);
1509                                        }
1510                                        break;
1511                                case LEADING_ASTERISK:
1512                                        {
1513                                        setState(310);
1514                                        match(LEADING_ASTERISK);
1515                                        }
1516                                        break;
1517                                case WS:
1518                                        {
1519                                        setState(311);
1520                                        match(WS);
1521                                        }
1522                                        break;
1523                                default:
1524                                        throw new NoViableAltException(this);
1525                                }
1526                                }
1527                                setState(316);
1528                                _errHandler.sync(this);
1529                                _la = _input.LA(1);
1530                        }
1531                        setState(317);
1532                        match(CLOSE);
1533                        }
1534                }
1535                catch (RecognitionException re) {
1536                        _localctx.exception = re;
1537                        _errHandler.reportError(this, re);
1538                        _errHandler.recover(this, re);
1539                }
1540                finally {
1541                        exitRule();
1542                }
1543                return _localctx;
1544        }
1545
1546        public static class PTagCloseContext extends ParserRuleContext {
1547                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1548                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1549                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1550                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1551                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1552                public TerminalNode NEWLINE(int i) {
1553                        return getToken(JavadocParser.NEWLINE, i);
1554                }
1555                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1556                public TerminalNode LEADING_ASTERISK(int i) {
1557                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1558                }
1559                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1560                public TerminalNode WS(int i) {
1561                        return getToken(JavadocParser.WS, i);
1562                }
1563                public PTagCloseContext(ParserRuleContext parent, int invokingState) {
1564                        super(parent, invokingState);
1565                }
1566                @Override public int getRuleIndex() { return RULE_pTagClose; }
1567                @Override
1568                public void enterRule(ParseTreeListener listener) {
1569                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this);
1570                }
1571                @Override
1572                public void exitRule(ParseTreeListener listener) {
1573                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this);
1574                }
1575                @Override
1576                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1577                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this);
1578                        else return visitor.visitChildren(this);
1579                }
1580        }
1581
1582        public final PTagCloseContext pTagClose() throws RecognitionException {
1583                PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState());
1584                enterRule(_localctx, 14, RULE_pTagClose);
1585                int _la;
1586                try {
1587                        enterOuterAlt(_localctx, 1);
1588                        {
1589                        setState(319);
1590                        match(OPEN);
1591                        setState(320);
1592                        match(SLASH);
1593                        setState(321);
1594                        match(P_HTML_TAG_NAME);
1595                        setState(325);
1596                        _errHandler.sync(this);
1597                        _la = _input.LA(1);
1598                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1599                                {
1600                                {
1601                                setState(322);
1602                                _la = _input.LA(1);
1603                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1604                                _errHandler.recoverInline(this);
1605                                } else {
1606                                        consume();
1607                                }
1608                                }
1609                                }
1610                                setState(327);
1611                                _errHandler.sync(this);
1612                                _la = _input.LA(1);
1613                        }
1614                        setState(328);
1615                        match(CLOSE);
1616                        }
1617                }
1618                catch (RecognitionException re) {
1619                        _localctx.exception = re;
1620                        _errHandler.reportError(this, re);
1621                        _errHandler.recover(this, re);
1622                }
1623                finally {
1624                        exitRule();
1625                }
1626                return _localctx;
1627        }
1628
1629        public static class ParagraphContext extends ParserRuleContext {
1630                public PTagOpenContext pTagOpen() {
1631                        return getRuleContext(PTagOpenContext.class,0);
1632                }
1633                public PTagCloseContext pTagClose() {
1634                        return getRuleContext(PTagCloseContext.class,0);
1635                }
1636                public List<HtmlTagContext> htmlTag() {
1637                        return getRuleContexts(HtmlTagContext.class);
1638                }
1639                public HtmlTagContext htmlTag(int i) {
1640                        return getRuleContext(HtmlTagContext.class,i);
1641                }
1642                public List<SingletonTagContext> singletonTag() {
1643                        return getRuleContexts(SingletonTagContext.class);
1644                }
1645                public SingletonTagContext singletonTag(int i) {
1646                        return getRuleContext(SingletonTagContext.class,i);
1647                }
1648                public List<LiContext> li() {
1649                        return getRuleContexts(LiContext.class);
1650                }
1651                public LiContext li(int i) {
1652                        return getRuleContext(LiContext.class,i);
1653                }
1654                public List<TrContext> tr() {
1655                        return getRuleContexts(TrContext.class);
1656                }
1657                public TrContext tr(int i) {
1658                        return getRuleContext(TrContext.class,i);
1659                }
1660                public List<TdContext> td() {
1661                        return getRuleContexts(TdContext.class);
1662                }
1663                public TdContext td(int i) {
1664                        return getRuleContext(TdContext.class,i);
1665                }
1666                public List<ThContext> th() {
1667                        return getRuleContexts(ThContext.class);
1668                }
1669                public ThContext th(int i) {
1670                        return getRuleContext(ThContext.class,i);
1671                }
1672                public List<BodyContext> body() {
1673                        return getRuleContexts(BodyContext.class);
1674                }
1675                public BodyContext body(int i) {
1676                        return getRuleContext(BodyContext.class,i);
1677                }
1678                public List<ColgroupContext> colgroup() {
1679                        return getRuleContexts(ColgroupContext.class);
1680                }
1681                public ColgroupContext colgroup(int i) {
1682                        return getRuleContext(ColgroupContext.class,i);
1683                }
1684                public List<DdContext> dd() {
1685                        return getRuleContexts(DdContext.class);
1686                }
1687                public DdContext dd(int i) {
1688                        return getRuleContext(DdContext.class,i);
1689                }
1690                public List<DtContext> dt() {
1691                        return getRuleContexts(DtContext.class);
1692                }
1693                public DtContext dt(int i) {
1694                        return getRuleContext(DtContext.class,i);
1695                }
1696                public List<HeadContext> head() {
1697                        return getRuleContexts(HeadContext.class);
1698                }
1699                public HeadContext head(int i) {
1700                        return getRuleContext(HeadContext.class,i);
1701                }
1702                public List<HtmlContext> html() {
1703                        return getRuleContexts(HtmlContext.class);
1704                }
1705                public HtmlContext html(int i) {
1706                        return getRuleContext(HtmlContext.class,i);
1707                }
1708                public List<OptionContext> option() {
1709                        return getRuleContexts(OptionContext.class);
1710                }
1711                public OptionContext option(int i) {
1712                        return getRuleContext(OptionContext.class,i);
1713                }
1714                public List<TbodyContext> tbody() {
1715                        return getRuleContexts(TbodyContext.class);
1716                }
1717                public TbodyContext tbody(int i) {
1718                        return getRuleContext(TbodyContext.class,i);
1719                }
1720                public List<TheadContext> thead() {
1721                        return getRuleContexts(TheadContext.class);
1722                }
1723                public TheadContext thead(int i) {
1724                        return getRuleContext(TheadContext.class,i);
1725                }
1726                public List<TfootContext> tfoot() {
1727                        return getRuleContexts(TfootContext.class);
1728                }
1729                public TfootContext tfoot(int i) {
1730                        return getRuleContext(TfootContext.class,i);
1731                }
1732                public List<LiTagOpenContext> liTagOpen() {
1733                        return getRuleContexts(LiTagOpenContext.class);
1734                }
1735                public LiTagOpenContext liTagOpen(int i) {
1736                        return getRuleContext(LiTagOpenContext.class,i);
1737                }
1738                public List<TrTagOpenContext> trTagOpen() {
1739                        return getRuleContexts(TrTagOpenContext.class);
1740                }
1741                public TrTagOpenContext trTagOpen(int i) {
1742                        return getRuleContext(TrTagOpenContext.class,i);
1743                }
1744                public List<TdTagOpenContext> tdTagOpen() {
1745                        return getRuleContexts(TdTagOpenContext.class);
1746                }
1747                public TdTagOpenContext tdTagOpen(int i) {
1748                        return getRuleContext(TdTagOpenContext.class,i);
1749                }
1750                public List<ThTagOpenContext> thTagOpen() {
1751                        return getRuleContexts(ThTagOpenContext.class);
1752                }
1753                public ThTagOpenContext thTagOpen(int i) {
1754                        return getRuleContext(ThTagOpenContext.class,i);
1755                }
1756                public List<BodyTagOpenContext> bodyTagOpen() {
1757                        return getRuleContexts(BodyTagOpenContext.class);
1758                }
1759                public BodyTagOpenContext bodyTagOpen(int i) {
1760                        return getRuleContext(BodyTagOpenContext.class,i);
1761                }
1762                public List<ColgroupTagOpenContext> colgroupTagOpen() {
1763                        return getRuleContexts(ColgroupTagOpenContext.class);
1764                }
1765                public ColgroupTagOpenContext colgroupTagOpen(int i) {
1766                        return getRuleContext(ColgroupTagOpenContext.class,i);
1767                }
1768                public List<DdTagOpenContext> ddTagOpen() {
1769                        return getRuleContexts(DdTagOpenContext.class);
1770                }
1771                public DdTagOpenContext ddTagOpen(int i) {
1772                        return getRuleContext(DdTagOpenContext.class,i);
1773                }
1774                public List<DtTagOpenContext> dtTagOpen() {
1775                        return getRuleContexts(DtTagOpenContext.class);
1776                }
1777                public DtTagOpenContext dtTagOpen(int i) {
1778                        return getRuleContext(DtTagOpenContext.class,i);
1779                }
1780                public List<HeadTagOpenContext> headTagOpen() {
1781                        return getRuleContexts(HeadTagOpenContext.class);
1782                }
1783                public HeadTagOpenContext headTagOpen(int i) {
1784                        return getRuleContext(HeadTagOpenContext.class,i);
1785                }
1786                public List<HtmlTagOpenContext> htmlTagOpen() {
1787                        return getRuleContexts(HtmlTagOpenContext.class);
1788                }
1789                public HtmlTagOpenContext htmlTagOpen(int i) {
1790                        return getRuleContext(HtmlTagOpenContext.class,i);
1791                }
1792                public List<OptionTagOpenContext> optionTagOpen() {
1793                        return getRuleContexts(OptionTagOpenContext.class);
1794                }
1795                public OptionTagOpenContext optionTagOpen(int i) {
1796                        return getRuleContext(OptionTagOpenContext.class,i);
1797                }
1798                public List<TbodyTagOpenContext> tbodyTagOpen() {
1799                        return getRuleContexts(TbodyTagOpenContext.class);
1800                }
1801                public TbodyTagOpenContext tbodyTagOpen(int i) {
1802                        return getRuleContext(TbodyTagOpenContext.class,i);
1803                }
1804                public List<TheadTagOpenContext> theadTagOpen() {
1805                        return getRuleContexts(TheadTagOpenContext.class);
1806                }
1807                public TheadTagOpenContext theadTagOpen(int i) {
1808                        return getRuleContext(TheadTagOpenContext.class,i);
1809                }
1810                public List<TfootTagOpenContext> tfootTagOpen() {
1811                        return getRuleContexts(TfootTagOpenContext.class);
1812                }
1813                public TfootTagOpenContext tfootTagOpen(int i) {
1814                        return getRuleContext(TfootTagOpenContext.class,i);
1815                }
1816                public List<HtmlCommentContext> htmlComment() {
1817                        return getRuleContexts(HtmlCommentContext.class);
1818                }
1819                public HtmlCommentContext htmlComment(int i) {
1820                        return getRuleContext(HtmlCommentContext.class,i);
1821                }
1822                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1823                public TerminalNode CDATA(int i) {
1824                        return getToken(JavadocParser.CDATA, i);
1825                }
1826                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1827                public TerminalNode NEWLINE(int i) {
1828                        return getToken(JavadocParser.NEWLINE, i);
1829                }
1830                public List<TextContext> text() {
1831                        return getRuleContexts(TextContext.class);
1832                }
1833                public TextContext text(int i) {
1834                        return getRuleContext(TextContext.class,i);
1835                }
1836                public List<JavadocInlineTagContext> javadocInlineTag() {
1837                        return getRuleContexts(JavadocInlineTagContext.class);
1838                }
1839                public JavadocInlineTagContext javadocInlineTag(int i) {
1840                        return getRuleContext(JavadocInlineTagContext.class,i);
1841                }
1842                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1843                public TerminalNode LEADING_ASTERISK(int i) {
1844                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1845                }
1846                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1847                        super(parent, invokingState);
1848                }
1849                @Override public int getRuleIndex() { return RULE_paragraph; }
1850                @Override
1851                public void enterRule(ParseTreeListener listener) {
1852                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this);
1853                }
1854                @Override
1855                public void exitRule(ParseTreeListener listener) {
1856                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this);
1857                }
1858                @Override
1859                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1860                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this);
1861                        else return visitor.visitChildren(this);
1862                }
1863        }
1864
1865        public final ParagraphContext paragraph() throws RecognitionException {
1866                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1867                enterRule(_localctx, 16, RULE_paragraph);
1868                try {
1869                        int _alt;
1870                        enterOuterAlt(_localctx, 1);
1871                        {
1872                        setState(330);
1873                        pTagOpen();
1874                        setState(370);
1875                        _errHandler.sync(this);
1876                        _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1877                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1878                                if ( _alt==1 ) {
1879                                        {
1880                                        setState(368);
1881                                        _errHandler.sync(this);
1882                                        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
1883                                        case 1:
1884                                                {
1885                                                setState(331);
1886                                                htmlTag();
1887                                                }
1888                                                break;
1889                                        case 2:
1890                                                {
1891                                                setState(332);
1892                                                singletonTag();
1893                                                }
1894                                                break;
1895                                        case 3:
1896                                                {
1897                                                setState(333);
1898                                                li();
1899                                                }
1900                                                break;
1901                                        case 4:
1902                                                {
1903                                                setState(334);
1904                                                tr();
1905                                                }
1906                                                break;
1907                                        case 5:
1908                                                {
1909                                                setState(335);
1910                                                td();
1911                                                }
1912                                                break;
1913                                        case 6:
1914                                                {
1915                                                setState(336);
1916                                                th();
1917                                                }
1918                                                break;
1919                                        case 7:
1920                                                {
1921                                                setState(337);
1922                                                body();
1923                                                }
1924                                                break;
1925                                        case 8:
1926                                                {
1927                                                setState(338);
1928                                                colgroup();
1929                                                }
1930                                                break;
1931                                        case 9:
1932                                                {
1933                                                setState(339);
1934                                                dd();
1935                                                }
1936                                                break;
1937                                        case 10:
1938                                                {
1939                                                setState(340);
1940                                                dt();
1941                                                }
1942                                                break;
1943                                        case 11:
1944                                                {
1945                                                setState(341);
1946                                                head();
1947                                                }
1948                                                break;
1949                                        case 12:
1950                                                {
1951                                                setState(342);
1952                                                html();
1953                                                }
1954                                                break;
1955                                        case 13:
1956                                                {
1957                                                setState(343);
1958                                                option();
1959                                                }
1960                                                break;
1961                                        case 14:
1962                                                {
1963                                                setState(344);
1964                                                tbody();
1965                                                }
1966                                                break;
1967                                        case 15:
1968                                                {
1969                                                setState(345);
1970                                                thead();
1971                                                }
1972                                                break;
1973                                        case 16:
1974                                                {
1975                                                setState(346);
1976                                                tfoot();
1977                                                }
1978                                                break;
1979                                        case 17:
1980                                                {
1981                                                setState(347);
1982                                                liTagOpen();
1983                                                }
1984                                                break;
1985                                        case 18:
1986                                                {
1987                                                setState(348);
1988                                                trTagOpen();
1989                                                }
1990                                                break;
1991                                        case 19:
1992                                                {
1993                                                setState(349);
1994                                                tdTagOpen();
1995                                                }
1996                                                break;
1997                                        case 20:
1998                                                {
1999                                                setState(350);
2000                                                thTagOpen();
2001                                                }
2002                                                break;
2003                                        case 21:
2004                                                {
2005                                                setState(351);
2006                                                bodyTagOpen();
2007                                                }
2008                                                break;
2009                                        case 22:
2010                                                {
2011                                                setState(352);
2012                                                colgroupTagOpen();
2013                                                }
2014                                                break;
2015                                        case 23:
2016                                                {
2017                                                setState(353);
2018                                                ddTagOpen();
2019                                                }
2020                                                break;
2021                                        case 24:
2022                                                {
2023                                                setState(354);
2024                                                dtTagOpen();
2025                                                }
2026                                                break;
2027                                        case 25:
2028                                                {
2029                                                setState(355);
2030                                                headTagOpen();
2031                                                }
2032                                                break;
2033                                        case 26:
2034                                                {
2035                                                setState(356);
2036                                                htmlTagOpen();
2037                                                }
2038                                                break;
2039                                        case 27:
2040                                                {
2041                                                setState(357);
2042                                                optionTagOpen();
2043                                                }
2044                                                break;
2045                                        case 28:
2046                                                {
2047                                                setState(358);
2048                                                tbodyTagOpen();
2049                                                }
2050                                                break;
2051                                        case 29:
2052                                                {
2053                                                setState(359);
2054                                                theadTagOpen();
2055                                                }
2056                                                break;
2057                                        case 30:
2058                                                {
2059                                                setState(360);
2060                                                tfootTagOpen();
2061                                                }
2062                                                break;
2063                                        case 31:
2064                                                {
2065                                                {
2066                                                setState(361);
2067                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2068                                                setState(362);
2069                                                match(LEADING_ASTERISK);
2070                                                }
2071                                                }
2072                                                break;
2073                                        case 32:
2074                                                {
2075                                                setState(363);
2076                                                htmlComment();
2077                                                }
2078                                                break;
2079                                        case 33:
2080                                                {
2081                                                setState(364);
2082                                                match(CDATA);
2083                                                }
2084                                                break;
2085                                        case 34:
2086                                                {
2087                                                setState(365);
2088                                                match(NEWLINE);
2089                                                }
2090                                                break;
2091                                        case 35:
2092                                                {
2093                                                setState(366);
2094                                                text();
2095                                                }
2096                                                break;
2097                                        case 36:
2098                                                {
2099                                                setState(367);
2100                                                javadocInlineTag();
2101                                                }
2102                                                break;
2103                                        }
2104                                        } 
2105                                }
2106                                setState(372);
2107                                _errHandler.sync(this);
2108                                _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
2109                        }
2110                        setState(373);
2111                        pTagClose();
2112                        }
2113                }
2114                catch (RecognitionException re) {
2115                        _localctx.exception = re;
2116                        _errHandler.reportError(this, re);
2117                        _errHandler.recover(this, re);
2118                }
2119                finally {
2120                        exitRule();
2121                }
2122                return _localctx;
2123        }
2124
2125        public static class LiTagOpenContext extends ParserRuleContext {
2126                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2127                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2128                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2129                public List<AttributeContext> attribute() {
2130                        return getRuleContexts(AttributeContext.class);
2131                }
2132                public AttributeContext attribute(int i) {
2133                        return getRuleContext(AttributeContext.class,i);
2134                }
2135                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2136                public TerminalNode NEWLINE(int i) {
2137                        return getToken(JavadocParser.NEWLINE, i);
2138                }
2139                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2140                public TerminalNode LEADING_ASTERISK(int i) {
2141                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2142                }
2143                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2144                public TerminalNode WS(int i) {
2145                        return getToken(JavadocParser.WS, i);
2146                }
2147                public LiTagOpenContext(ParserRuleContext parent, int invokingState) {
2148                        super(parent, invokingState);
2149                }
2150                @Override public int getRuleIndex() { return RULE_liTagOpen; }
2151                @Override
2152                public void enterRule(ParseTreeListener listener) {
2153                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this);
2154                }
2155                @Override
2156                public void exitRule(ParseTreeListener listener) {
2157                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this);
2158                }
2159                @Override
2160                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2161                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this);
2162                        else return visitor.visitChildren(this);
2163                }
2164        }
2165
2166        public final LiTagOpenContext liTagOpen() throws RecognitionException {
2167                LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState());
2168                enterRule(_localctx, 18, RULE_liTagOpen);
2169                int _la;
2170                try {
2171                        enterOuterAlt(_localctx, 1);
2172                        {
2173                        setState(375);
2174                        match(OPEN);
2175                        setState(376);
2176                        match(LI_HTML_TAG_NAME);
2177                        setState(383);
2178                        _errHandler.sync(this);
2179                        _la = _input.LA(1);
2180                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2181                                {
2182                                setState(381);
2183                                switch (_input.LA(1)) {
2184                                case HTML_TAG_NAME:
2185                                        {
2186                                        setState(377);
2187                                        attribute();
2188                                        }
2189                                        break;
2190                                case NEWLINE:
2191                                        {
2192                                        setState(378);
2193                                        match(NEWLINE);
2194                                        }
2195                                        break;
2196                                case LEADING_ASTERISK:
2197                                        {
2198                                        setState(379);
2199                                        match(LEADING_ASTERISK);
2200                                        }
2201                                        break;
2202                                case WS:
2203                                        {
2204                                        setState(380);
2205                                        match(WS);
2206                                        }
2207                                        break;
2208                                default:
2209                                        throw new NoViableAltException(this);
2210                                }
2211                                }
2212                                setState(385);
2213                                _errHandler.sync(this);
2214                                _la = _input.LA(1);
2215                        }
2216                        setState(386);
2217                        match(CLOSE);
2218                        }
2219                }
2220                catch (RecognitionException re) {
2221                        _localctx.exception = re;
2222                        _errHandler.reportError(this, re);
2223                        _errHandler.recover(this, re);
2224                }
2225                finally {
2226                        exitRule();
2227                }
2228                return _localctx;
2229        }
2230
2231        public static class LiTagCloseContext extends ParserRuleContext {
2232                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2233                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2234                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2235                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2236                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2237                public TerminalNode NEWLINE(int i) {
2238                        return getToken(JavadocParser.NEWLINE, i);
2239                }
2240                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2241                public TerminalNode LEADING_ASTERISK(int i) {
2242                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2243                }
2244                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2245                public TerminalNode WS(int i) {
2246                        return getToken(JavadocParser.WS, i);
2247                }
2248                public LiTagCloseContext(ParserRuleContext parent, int invokingState) {
2249                        super(parent, invokingState);
2250                }
2251                @Override public int getRuleIndex() { return RULE_liTagClose; }
2252                @Override
2253                public void enterRule(ParseTreeListener listener) {
2254                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this);
2255                }
2256                @Override
2257                public void exitRule(ParseTreeListener listener) {
2258                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this);
2259                }
2260                @Override
2261                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2262                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this);
2263                        else return visitor.visitChildren(this);
2264                }
2265        }
2266
2267        public final LiTagCloseContext liTagClose() throws RecognitionException {
2268                LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState());
2269                enterRule(_localctx, 20, RULE_liTagClose);
2270                int _la;
2271                try {
2272                        enterOuterAlt(_localctx, 1);
2273                        {
2274                        setState(388);
2275                        match(OPEN);
2276                        setState(389);
2277                        match(SLASH);
2278                        setState(390);
2279                        match(LI_HTML_TAG_NAME);
2280                        setState(394);
2281                        _errHandler.sync(this);
2282                        _la = _input.LA(1);
2283                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2284                                {
2285                                {
2286                                setState(391);
2287                                _la = _input.LA(1);
2288                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2289                                _errHandler.recoverInline(this);
2290                                } else {
2291                                        consume();
2292                                }
2293                                }
2294                                }
2295                                setState(396);
2296                                _errHandler.sync(this);
2297                                _la = _input.LA(1);
2298                        }
2299                        setState(397);
2300                        match(CLOSE);
2301                        }
2302                }
2303                catch (RecognitionException re) {
2304                        _localctx.exception = re;
2305                        _errHandler.reportError(this, re);
2306                        _errHandler.recover(this, re);
2307                }
2308                finally {
2309                        exitRule();
2310                }
2311                return _localctx;
2312        }
2313
2314        public static class LiContext extends ParserRuleContext {
2315                public LiTagOpenContext liTagOpen() {
2316                        return getRuleContext(LiTagOpenContext.class,0);
2317                }
2318                public LiTagCloseContext liTagClose() {
2319                        return getRuleContext(LiTagCloseContext.class,0);
2320                }
2321                public List<HtmlTagContext> htmlTag() {
2322                        return getRuleContexts(HtmlTagContext.class);
2323                }
2324                public HtmlTagContext htmlTag(int i) {
2325                        return getRuleContext(HtmlTagContext.class,i);
2326                }
2327                public List<SingletonTagContext> singletonTag() {
2328                        return getRuleContexts(SingletonTagContext.class);
2329                }
2330                public SingletonTagContext singletonTag(int i) {
2331                        return getRuleContext(SingletonTagContext.class,i);
2332                }
2333                public List<ParagraphContext> paragraph() {
2334                        return getRuleContexts(ParagraphContext.class);
2335                }
2336                public ParagraphContext paragraph(int i) {
2337                        return getRuleContext(ParagraphContext.class,i);
2338                }
2339                public List<TrContext> tr() {
2340                        return getRuleContexts(TrContext.class);
2341                }
2342                public TrContext tr(int i) {
2343                        return getRuleContext(TrContext.class,i);
2344                }
2345                public List<TdContext> td() {
2346                        return getRuleContexts(TdContext.class);
2347                }
2348                public TdContext td(int i) {
2349                        return getRuleContext(TdContext.class,i);
2350                }
2351                public List<ThContext> th() {
2352                        return getRuleContexts(ThContext.class);
2353                }
2354                public ThContext th(int i) {
2355                        return getRuleContext(ThContext.class,i);
2356                }
2357                public List<BodyContext> body() {
2358                        return getRuleContexts(BodyContext.class);
2359                }
2360                public BodyContext body(int i) {
2361                        return getRuleContext(BodyContext.class,i);
2362                }
2363                public List<ColgroupContext> colgroup() {
2364                        return getRuleContexts(ColgroupContext.class);
2365                }
2366                public ColgroupContext colgroup(int i) {
2367                        return getRuleContext(ColgroupContext.class,i);
2368                }
2369                public List<DdContext> dd() {
2370                        return getRuleContexts(DdContext.class);
2371                }
2372                public DdContext dd(int i) {
2373                        return getRuleContext(DdContext.class,i);
2374                }
2375                public List<DtContext> dt() {
2376                        return getRuleContexts(DtContext.class);
2377                }
2378                public DtContext dt(int i) {
2379                        return getRuleContext(DtContext.class,i);
2380                }
2381                public List<HeadContext> head() {
2382                        return getRuleContexts(HeadContext.class);
2383                }
2384                public HeadContext head(int i) {
2385                        return getRuleContext(HeadContext.class,i);
2386                }
2387                public List<HtmlContext> html() {
2388                        return getRuleContexts(HtmlContext.class);
2389                }
2390                public HtmlContext html(int i) {
2391                        return getRuleContext(HtmlContext.class,i);
2392                }
2393                public List<OptionContext> option() {
2394                        return getRuleContexts(OptionContext.class);
2395                }
2396                public OptionContext option(int i) {
2397                        return getRuleContext(OptionContext.class,i);
2398                }
2399                public List<TbodyContext> tbody() {
2400                        return getRuleContexts(TbodyContext.class);
2401                }
2402                public TbodyContext tbody(int i) {
2403                        return getRuleContext(TbodyContext.class,i);
2404                }
2405                public List<TheadContext> thead() {
2406                        return getRuleContexts(TheadContext.class);
2407                }
2408                public TheadContext thead(int i) {
2409                        return getRuleContext(TheadContext.class,i);
2410                }
2411                public List<TfootContext> tfoot() {
2412                        return getRuleContexts(TfootContext.class);
2413                }
2414                public TfootContext tfoot(int i) {
2415                        return getRuleContext(TfootContext.class,i);
2416                }
2417                public List<PTagOpenContext> pTagOpen() {
2418                        return getRuleContexts(PTagOpenContext.class);
2419                }
2420                public PTagOpenContext pTagOpen(int i) {
2421                        return getRuleContext(PTagOpenContext.class,i);
2422                }
2423                public List<TrTagOpenContext> trTagOpen() {
2424                        return getRuleContexts(TrTagOpenContext.class);
2425                }
2426                public TrTagOpenContext trTagOpen(int i) {
2427                        return getRuleContext(TrTagOpenContext.class,i);
2428                }
2429                public List<TdTagOpenContext> tdTagOpen() {
2430                        return getRuleContexts(TdTagOpenContext.class);
2431                }
2432                public TdTagOpenContext tdTagOpen(int i) {
2433                        return getRuleContext(TdTagOpenContext.class,i);
2434                }
2435                public List<ThTagOpenContext> thTagOpen() {
2436                        return getRuleContexts(ThTagOpenContext.class);
2437                }
2438                public ThTagOpenContext thTagOpen(int i) {
2439                        return getRuleContext(ThTagOpenContext.class,i);
2440                }
2441                public List<BodyTagOpenContext> bodyTagOpen() {
2442                        return getRuleContexts(BodyTagOpenContext.class);
2443                }
2444                public BodyTagOpenContext bodyTagOpen(int i) {
2445                        return getRuleContext(BodyTagOpenContext.class,i);
2446                }
2447                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2448                        return getRuleContexts(ColgroupTagOpenContext.class);
2449                }
2450                public ColgroupTagOpenContext colgroupTagOpen(int i) {
2451                        return getRuleContext(ColgroupTagOpenContext.class,i);
2452                }
2453                public List<DdTagOpenContext> ddTagOpen() {
2454                        return getRuleContexts(DdTagOpenContext.class);
2455                }
2456                public DdTagOpenContext ddTagOpen(int i) {
2457                        return getRuleContext(DdTagOpenContext.class,i);
2458                }
2459                public List<DtTagOpenContext> dtTagOpen() {
2460                        return getRuleContexts(DtTagOpenContext.class);
2461                }
2462                public DtTagOpenContext dtTagOpen(int i) {
2463                        return getRuleContext(DtTagOpenContext.class,i);
2464                }
2465                public List<HeadTagOpenContext> headTagOpen() {
2466                        return getRuleContexts(HeadTagOpenContext.class);
2467                }
2468                public HeadTagOpenContext headTagOpen(int i) {
2469                        return getRuleContext(HeadTagOpenContext.class,i);
2470                }
2471                public List<HtmlTagOpenContext> htmlTagOpen() {
2472                        return getRuleContexts(HtmlTagOpenContext.class);
2473                }
2474                public HtmlTagOpenContext htmlTagOpen(int i) {
2475                        return getRuleContext(HtmlTagOpenContext.class,i);
2476                }
2477                public List<OptionTagOpenContext> optionTagOpen() {
2478                        return getRuleContexts(OptionTagOpenContext.class);
2479                }
2480                public OptionTagOpenContext optionTagOpen(int i) {
2481                        return getRuleContext(OptionTagOpenContext.class,i);
2482                }
2483                public List<TbodyTagOpenContext> tbodyTagOpen() {
2484                        return getRuleContexts(TbodyTagOpenContext.class);
2485                }
2486                public TbodyTagOpenContext tbodyTagOpen(int i) {
2487                        return getRuleContext(TbodyTagOpenContext.class,i);
2488                }
2489                public List<TheadTagOpenContext> theadTagOpen() {
2490                        return getRuleContexts(TheadTagOpenContext.class);
2491                }
2492                public TheadTagOpenContext theadTagOpen(int i) {
2493                        return getRuleContext(TheadTagOpenContext.class,i);
2494                }
2495                public List<TfootTagOpenContext> tfootTagOpen() {
2496                        return getRuleContexts(TfootTagOpenContext.class);
2497                }
2498                public TfootTagOpenContext tfootTagOpen(int i) {
2499                        return getRuleContext(TfootTagOpenContext.class,i);
2500                }
2501                public List<HtmlCommentContext> htmlComment() {
2502                        return getRuleContexts(HtmlCommentContext.class);
2503                }
2504                public HtmlCommentContext htmlComment(int i) {
2505                        return getRuleContext(HtmlCommentContext.class,i);
2506                }
2507                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2508                public TerminalNode CDATA(int i) {
2509                        return getToken(JavadocParser.CDATA, i);
2510                }
2511                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2512                public TerminalNode NEWLINE(int i) {
2513                        return getToken(JavadocParser.NEWLINE, i);
2514                }
2515                public List<TextContext> text() {
2516                        return getRuleContexts(TextContext.class);
2517                }
2518                public TextContext text(int i) {
2519                        return getRuleContext(TextContext.class,i);
2520                }
2521                public List<JavadocInlineTagContext> javadocInlineTag() {
2522                        return getRuleContexts(JavadocInlineTagContext.class);
2523                }
2524                public JavadocInlineTagContext javadocInlineTag(int i) {
2525                        return getRuleContext(JavadocInlineTagContext.class,i);
2526                }
2527                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2528                public TerminalNode LEADING_ASTERISK(int i) {
2529                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2530                }
2531                public LiContext(ParserRuleContext parent, int invokingState) {
2532                        super(parent, invokingState);
2533                }
2534                @Override public int getRuleIndex() { return RULE_li; }
2535                @Override
2536                public void enterRule(ParseTreeListener listener) {
2537                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this);
2538                }
2539                @Override
2540                public void exitRule(ParseTreeListener listener) {
2541                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this);
2542                }
2543                @Override
2544                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2545                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this);
2546                        else return visitor.visitChildren(this);
2547                }
2548        }
2549
2550        public final LiContext li() throws RecognitionException {
2551                LiContext _localctx = new LiContext(_ctx, getState());
2552                enterRule(_localctx, 22, RULE_li);
2553                try {
2554                        int _alt;
2555                        enterOuterAlt(_localctx, 1);
2556                        {
2557                        setState(399);
2558                        liTagOpen();
2559                        setState(439);
2560                        _errHandler.sync(this);
2561                        _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2562                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2563                                if ( _alt==1 ) {
2564                                        {
2565                                        setState(437);
2566                                        _errHandler.sync(this);
2567                                        switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
2568                                        case 1:
2569                                                {
2570                                                setState(400);
2571                                                htmlTag();
2572                                                }
2573                                                break;
2574                                        case 2:
2575                                                {
2576                                                setState(401);
2577                                                singletonTag();
2578                                                }
2579                                                break;
2580                                        case 3:
2581                                                {
2582                                                setState(402);
2583                                                paragraph();
2584                                                }
2585                                                break;
2586                                        case 4:
2587                                                {
2588                                                setState(403);
2589                                                tr();
2590                                                }
2591                                                break;
2592                                        case 5:
2593                                                {
2594                                                setState(404);
2595                                                td();
2596                                                }
2597                                                break;
2598                                        case 6:
2599                                                {
2600                                                setState(405);
2601                                                th();
2602                                                }
2603                                                break;
2604                                        case 7:
2605                                                {
2606                                                setState(406);
2607                                                body();
2608                                                }
2609                                                break;
2610                                        case 8:
2611                                                {
2612                                                setState(407);
2613                                                colgroup();
2614                                                }
2615                                                break;
2616                                        case 9:
2617                                                {
2618                                                setState(408);
2619                                                dd();
2620                                                }
2621                                                break;
2622                                        case 10:
2623                                                {
2624                                                setState(409);
2625                                                dt();
2626                                                }
2627                                                break;
2628                                        case 11:
2629                                                {
2630                                                setState(410);
2631                                                head();
2632                                                }
2633                                                break;
2634                                        case 12:
2635                                                {
2636                                                setState(411);
2637                                                html();
2638                                                }
2639                                                break;
2640                                        case 13:
2641                                                {
2642                                                setState(412);
2643                                                option();
2644                                                }
2645                                                break;
2646                                        case 14:
2647                                                {
2648                                                setState(413);
2649                                                tbody();
2650                                                }
2651                                                break;
2652                                        case 15:
2653                                                {
2654                                                setState(414);
2655                                                thead();
2656                                                }
2657                                                break;
2658                                        case 16:
2659                                                {
2660                                                setState(415);
2661                                                tfoot();
2662                                                }
2663                                                break;
2664                                        case 17:
2665                                                {
2666                                                setState(416);
2667                                                pTagOpen();
2668                                                }
2669                                                break;
2670                                        case 18:
2671                                                {
2672                                                setState(417);
2673                                                trTagOpen();
2674                                                }
2675                                                break;
2676                                        case 19:
2677                                                {
2678                                                setState(418);
2679                                                tdTagOpen();
2680                                                }
2681                                                break;
2682                                        case 20:
2683                                                {
2684                                                setState(419);
2685                                                thTagOpen();
2686                                                }
2687                                                break;
2688                                        case 21:
2689                                                {
2690                                                setState(420);
2691                                                bodyTagOpen();
2692                                                }
2693                                                break;
2694                                        case 22:
2695                                                {
2696                                                setState(421);
2697                                                colgroupTagOpen();
2698                                                }
2699                                                break;
2700                                        case 23:
2701                                                {
2702                                                setState(422);
2703                                                ddTagOpen();
2704                                                }
2705                                                break;
2706                                        case 24:
2707                                                {
2708                                                setState(423);
2709                                                dtTagOpen();
2710                                                }
2711                                                break;
2712                                        case 25:
2713                                                {
2714                                                setState(424);
2715                                                headTagOpen();
2716                                                }
2717                                                break;
2718                                        case 26:
2719                                                {
2720                                                setState(425);
2721                                                htmlTagOpen();
2722                                                }
2723                                                break;
2724                                        case 27:
2725                                                {
2726                                                setState(426);
2727                                                optionTagOpen();
2728                                                }
2729                                                break;
2730                                        case 28:
2731                                                {
2732                                                setState(427);
2733                                                tbodyTagOpen();
2734                                                }
2735                                                break;
2736                                        case 29:
2737                                                {
2738                                                setState(428);
2739                                                theadTagOpen();
2740                                                }
2741                                                break;
2742                                        case 30:
2743                                                {
2744                                                setState(429);
2745                                                tfootTagOpen();
2746                                                }
2747                                                break;
2748                                        case 31:
2749                                                {
2750                                                {
2751                                                setState(430);
2752                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2753                                                setState(431);
2754                                                match(LEADING_ASTERISK);
2755                                                }
2756                                                }
2757                                                break;
2758                                        case 32:
2759                                                {
2760                                                setState(432);
2761                                                htmlComment();
2762                                                }
2763                                                break;
2764                                        case 33:
2765                                                {
2766                                                setState(433);
2767                                                match(CDATA);
2768                                                }
2769                                                break;
2770                                        case 34:
2771                                                {
2772                                                setState(434);
2773                                                match(NEWLINE);
2774                                                }
2775                                                break;
2776                                        case 35:
2777                                                {
2778                                                setState(435);
2779                                                text();
2780                                                }
2781                                                break;
2782                                        case 36:
2783                                                {
2784                                                setState(436);
2785                                                javadocInlineTag();
2786                                                }
2787                                                break;
2788                                        }
2789                                        } 
2790                                }
2791                                setState(441);
2792                                _errHandler.sync(this);
2793                                _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2794                        }
2795                        setState(442);
2796                        liTagClose();
2797                        }
2798                }
2799                catch (RecognitionException re) {
2800                        _localctx.exception = re;
2801                        _errHandler.reportError(this, re);
2802                        _errHandler.recover(this, re);
2803                }
2804                finally {
2805                        exitRule();
2806                }
2807                return _localctx;
2808        }
2809
2810        public static class TrTagOpenContext extends ParserRuleContext {
2811                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2812                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2813                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2814                public List<AttributeContext> attribute() {
2815                        return getRuleContexts(AttributeContext.class);
2816                }
2817                public AttributeContext attribute(int i) {
2818                        return getRuleContext(AttributeContext.class,i);
2819                }
2820                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2821                public TerminalNode NEWLINE(int i) {
2822                        return getToken(JavadocParser.NEWLINE, i);
2823                }
2824                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2825                public TerminalNode LEADING_ASTERISK(int i) {
2826                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2827                }
2828                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2829                public TerminalNode WS(int i) {
2830                        return getToken(JavadocParser.WS, i);
2831                }
2832                public TrTagOpenContext(ParserRuleContext parent, int invokingState) {
2833                        super(parent, invokingState);
2834                }
2835                @Override public int getRuleIndex() { return RULE_trTagOpen; }
2836                @Override
2837                public void enterRule(ParseTreeListener listener) {
2838                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this);
2839                }
2840                @Override
2841                public void exitRule(ParseTreeListener listener) {
2842                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this);
2843                }
2844                @Override
2845                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2846                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this);
2847                        else return visitor.visitChildren(this);
2848                }
2849        }
2850
2851        public final TrTagOpenContext trTagOpen() throws RecognitionException {
2852                TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState());
2853                enterRule(_localctx, 24, RULE_trTagOpen);
2854                int _la;
2855                try {
2856                        enterOuterAlt(_localctx, 1);
2857                        {
2858                        setState(444);
2859                        match(OPEN);
2860                        setState(445);
2861                        match(TR_HTML_TAG_NAME);
2862                        setState(452);
2863                        _errHandler.sync(this);
2864                        _la = _input.LA(1);
2865                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2866                                {
2867                                setState(450);
2868                                switch (_input.LA(1)) {
2869                                case HTML_TAG_NAME:
2870                                        {
2871                                        setState(446);
2872                                        attribute();
2873                                        }
2874                                        break;
2875                                case NEWLINE:
2876                                        {
2877                                        setState(447);
2878                                        match(NEWLINE);
2879                                        }
2880                                        break;
2881                                case LEADING_ASTERISK:
2882                                        {
2883                                        setState(448);
2884                                        match(LEADING_ASTERISK);
2885                                        }
2886                                        break;
2887                                case WS:
2888                                        {
2889                                        setState(449);
2890                                        match(WS);
2891                                        }
2892                                        break;
2893                                default:
2894                                        throw new NoViableAltException(this);
2895                                }
2896                                }
2897                                setState(454);
2898                                _errHandler.sync(this);
2899                                _la = _input.LA(1);
2900                        }
2901                        setState(455);
2902                        match(CLOSE);
2903                        }
2904                }
2905                catch (RecognitionException re) {
2906                        _localctx.exception = re;
2907                        _errHandler.reportError(this, re);
2908                        _errHandler.recover(this, re);
2909                }
2910                finally {
2911                        exitRule();
2912                }
2913                return _localctx;
2914        }
2915
2916        public static class TrTagCloseContext extends ParserRuleContext {
2917                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2918                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2919                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2920                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2921                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2922                public TerminalNode NEWLINE(int i) {
2923                        return getToken(JavadocParser.NEWLINE, i);
2924                }
2925                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2926                public TerminalNode LEADING_ASTERISK(int i) {
2927                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2928                }
2929                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2930                public TerminalNode WS(int i) {
2931                        return getToken(JavadocParser.WS, i);
2932                }
2933                public TrTagCloseContext(ParserRuleContext parent, int invokingState) {
2934                        super(parent, invokingState);
2935                }
2936                @Override public int getRuleIndex() { return RULE_trTagClose; }
2937                @Override
2938                public void enterRule(ParseTreeListener listener) {
2939                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this);
2940                }
2941                @Override
2942                public void exitRule(ParseTreeListener listener) {
2943                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this);
2944                }
2945                @Override
2946                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2947                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this);
2948                        else return visitor.visitChildren(this);
2949                }
2950        }
2951
2952        public final TrTagCloseContext trTagClose() throws RecognitionException {
2953                TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState());
2954                enterRule(_localctx, 26, RULE_trTagClose);
2955                int _la;
2956                try {
2957                        enterOuterAlt(_localctx, 1);
2958                        {
2959                        setState(457);
2960                        match(OPEN);
2961                        setState(458);
2962                        match(SLASH);
2963                        setState(459);
2964                        match(TR_HTML_TAG_NAME);
2965                        setState(463);
2966                        _errHandler.sync(this);
2967                        _la = _input.LA(1);
2968                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2969                                {
2970                                {
2971                                setState(460);
2972                                _la = _input.LA(1);
2973                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2974                                _errHandler.recoverInline(this);
2975                                } else {
2976                                        consume();
2977                                }
2978                                }
2979                                }
2980                                setState(465);
2981                                _errHandler.sync(this);
2982                                _la = _input.LA(1);
2983                        }
2984                        setState(466);
2985                        match(CLOSE);
2986                        }
2987                }
2988                catch (RecognitionException re) {
2989                        _localctx.exception = re;
2990                        _errHandler.reportError(this, re);
2991                        _errHandler.recover(this, re);
2992                }
2993                finally {
2994                        exitRule();
2995                }
2996                return _localctx;
2997        }
2998
2999        public static class TrContext extends ParserRuleContext {
3000                public TrTagOpenContext trTagOpen() {
3001                        return getRuleContext(TrTagOpenContext.class,0);
3002                }
3003                public TrTagCloseContext trTagClose() {
3004                        return getRuleContext(TrTagCloseContext.class,0);
3005                }
3006                public List<HtmlTagContext> htmlTag() {
3007                        return getRuleContexts(HtmlTagContext.class);
3008                }
3009                public HtmlTagContext htmlTag(int i) {
3010                        return getRuleContext(HtmlTagContext.class,i);
3011                }
3012                public List<SingletonTagContext> singletonTag() {
3013                        return getRuleContexts(SingletonTagContext.class);
3014                }
3015                public SingletonTagContext singletonTag(int i) {
3016                        return getRuleContext(SingletonTagContext.class,i);
3017                }
3018                public List<ParagraphContext> paragraph() {
3019                        return getRuleContexts(ParagraphContext.class);
3020                }
3021                public ParagraphContext paragraph(int i) {
3022                        return getRuleContext(ParagraphContext.class,i);
3023                }
3024                public List<LiContext> li() {
3025                        return getRuleContexts(LiContext.class);
3026                }
3027                public LiContext li(int i) {
3028                        return getRuleContext(LiContext.class,i);
3029                }
3030                public List<TdContext> td() {
3031                        return getRuleContexts(TdContext.class);
3032                }
3033                public TdContext td(int i) {
3034                        return getRuleContext(TdContext.class,i);
3035                }
3036                public List<ThContext> th() {
3037                        return getRuleContexts(ThContext.class);
3038                }
3039                public ThContext th(int i) {
3040                        return getRuleContext(ThContext.class,i);
3041                }
3042                public List<BodyContext> body() {
3043                        return getRuleContexts(BodyContext.class);
3044                }
3045                public BodyContext body(int i) {
3046                        return getRuleContext(BodyContext.class,i);
3047                }
3048                public List<ColgroupContext> colgroup() {
3049                        return getRuleContexts(ColgroupContext.class);
3050                }
3051                public ColgroupContext colgroup(int i) {
3052                        return getRuleContext(ColgroupContext.class,i);
3053                }
3054                public List<DdContext> dd() {
3055                        return getRuleContexts(DdContext.class);
3056                }
3057                public DdContext dd(int i) {
3058                        return getRuleContext(DdContext.class,i);
3059                }
3060                public List<DtContext> dt() {
3061                        return getRuleContexts(DtContext.class);
3062                }
3063                public DtContext dt(int i) {
3064                        return getRuleContext(DtContext.class,i);
3065                }
3066                public List<HeadContext> head() {
3067                        return getRuleContexts(HeadContext.class);
3068                }
3069                public HeadContext head(int i) {
3070                        return getRuleContext(HeadContext.class,i);
3071                }
3072                public List<HtmlContext> html() {
3073                        return getRuleContexts(HtmlContext.class);
3074                }
3075                public HtmlContext html(int i) {
3076                        return getRuleContext(HtmlContext.class,i);
3077                }
3078                public List<OptionContext> option() {
3079                        return getRuleContexts(OptionContext.class);
3080                }
3081                public OptionContext option(int i) {
3082                        return getRuleContext(OptionContext.class,i);
3083                }
3084                public List<TbodyContext> tbody() {
3085                        return getRuleContexts(TbodyContext.class);
3086                }
3087                public TbodyContext tbody(int i) {
3088                        return getRuleContext(TbodyContext.class,i);
3089                }
3090                public List<TheadContext> thead() {
3091                        return getRuleContexts(TheadContext.class);
3092                }
3093                public TheadContext thead(int i) {
3094                        return getRuleContext(TheadContext.class,i);
3095                }
3096                public List<TfootContext> tfoot() {
3097                        return getRuleContexts(TfootContext.class);
3098                }
3099                public TfootContext tfoot(int i) {
3100                        return getRuleContext(TfootContext.class,i);
3101                }
3102                public List<PTagOpenContext> pTagOpen() {
3103                        return getRuleContexts(PTagOpenContext.class);
3104                }
3105                public PTagOpenContext pTagOpen(int i) {
3106                        return getRuleContext(PTagOpenContext.class,i);
3107                }
3108                public List<LiTagOpenContext> liTagOpen() {
3109                        return getRuleContexts(LiTagOpenContext.class);
3110                }
3111                public LiTagOpenContext liTagOpen(int i) {
3112                        return getRuleContext(LiTagOpenContext.class,i);
3113                }
3114                public List<TdTagOpenContext> tdTagOpen() {
3115                        return getRuleContexts(TdTagOpenContext.class);
3116                }
3117                public TdTagOpenContext tdTagOpen(int i) {
3118                        return getRuleContext(TdTagOpenContext.class,i);
3119                }
3120                public List<ThTagOpenContext> thTagOpen() {
3121                        return getRuleContexts(ThTagOpenContext.class);
3122                }
3123                public ThTagOpenContext thTagOpen(int i) {
3124                        return getRuleContext(ThTagOpenContext.class,i);
3125                }
3126                public List<BodyTagOpenContext> bodyTagOpen() {
3127                        return getRuleContexts(BodyTagOpenContext.class);
3128                }
3129                public BodyTagOpenContext bodyTagOpen(int i) {
3130                        return getRuleContext(BodyTagOpenContext.class,i);
3131                }
3132                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3133                        return getRuleContexts(ColgroupTagOpenContext.class);
3134                }
3135                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3136                        return getRuleContext(ColgroupTagOpenContext.class,i);
3137                }
3138                public List<DdTagOpenContext> ddTagOpen() {
3139                        return getRuleContexts(DdTagOpenContext.class);
3140                }
3141                public DdTagOpenContext ddTagOpen(int i) {
3142                        return getRuleContext(DdTagOpenContext.class,i);
3143                }
3144                public List<DtTagOpenContext> dtTagOpen() {
3145                        return getRuleContexts(DtTagOpenContext.class);
3146                }
3147                public DtTagOpenContext dtTagOpen(int i) {
3148                        return getRuleContext(DtTagOpenContext.class,i);
3149                }
3150                public List<HeadTagOpenContext> headTagOpen() {
3151                        return getRuleContexts(HeadTagOpenContext.class);
3152                }
3153                public HeadTagOpenContext headTagOpen(int i) {
3154                        return getRuleContext(HeadTagOpenContext.class,i);
3155                }
3156                public List<HtmlTagOpenContext> htmlTagOpen() {
3157                        return getRuleContexts(HtmlTagOpenContext.class);
3158                }
3159                public HtmlTagOpenContext htmlTagOpen(int i) {
3160                        return getRuleContext(HtmlTagOpenContext.class,i);
3161                }
3162                public List<OptionTagOpenContext> optionTagOpen() {
3163                        return getRuleContexts(OptionTagOpenContext.class);
3164                }
3165                public OptionTagOpenContext optionTagOpen(int i) {
3166                        return getRuleContext(OptionTagOpenContext.class,i);
3167                }
3168                public List<TbodyTagOpenContext> tbodyTagOpen() {
3169                        return getRuleContexts(TbodyTagOpenContext.class);
3170                }
3171                public TbodyTagOpenContext tbodyTagOpen(int i) {
3172                        return getRuleContext(TbodyTagOpenContext.class,i);
3173                }
3174                public List<TheadTagOpenContext> theadTagOpen() {
3175                        return getRuleContexts(TheadTagOpenContext.class);
3176                }
3177                public TheadTagOpenContext theadTagOpen(int i) {
3178                        return getRuleContext(TheadTagOpenContext.class,i);
3179                }
3180                public List<TfootTagOpenContext> tfootTagOpen() {
3181                        return getRuleContexts(TfootTagOpenContext.class);
3182                }
3183                public TfootTagOpenContext tfootTagOpen(int i) {
3184                        return getRuleContext(TfootTagOpenContext.class,i);
3185                }
3186                public List<HtmlCommentContext> htmlComment() {
3187                        return getRuleContexts(HtmlCommentContext.class);
3188                }
3189                public HtmlCommentContext htmlComment(int i) {
3190                        return getRuleContext(HtmlCommentContext.class,i);
3191                }
3192                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3193                public TerminalNode CDATA(int i) {
3194                        return getToken(JavadocParser.CDATA, i);
3195                }
3196                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3197                public TerminalNode NEWLINE(int i) {
3198                        return getToken(JavadocParser.NEWLINE, i);
3199                }
3200                public List<TextContext> text() {
3201                        return getRuleContexts(TextContext.class);
3202                }
3203                public TextContext text(int i) {
3204                        return getRuleContext(TextContext.class,i);
3205                }
3206                public List<JavadocInlineTagContext> javadocInlineTag() {
3207                        return getRuleContexts(JavadocInlineTagContext.class);
3208                }
3209                public JavadocInlineTagContext javadocInlineTag(int i) {
3210                        return getRuleContext(JavadocInlineTagContext.class,i);
3211                }
3212                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3213                public TerminalNode LEADING_ASTERISK(int i) {
3214                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3215                }
3216                public TrContext(ParserRuleContext parent, int invokingState) {
3217                        super(parent, invokingState);
3218                }
3219                @Override public int getRuleIndex() { return RULE_tr; }
3220                @Override
3221                public void enterRule(ParseTreeListener listener) {
3222                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this);
3223                }
3224                @Override
3225                public void exitRule(ParseTreeListener listener) {
3226                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this);
3227                }
3228                @Override
3229                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3230                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this);
3231                        else return visitor.visitChildren(this);
3232                }
3233        }
3234
3235        public final TrContext tr() throws RecognitionException {
3236                TrContext _localctx = new TrContext(_ctx, getState());
3237                enterRule(_localctx, 28, RULE_tr);
3238                try {
3239                        int _alt;
3240                        enterOuterAlt(_localctx, 1);
3241                        {
3242                        setState(468);
3243                        trTagOpen();
3244                        setState(508);
3245                        _errHandler.sync(this);
3246                        _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3247                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3248                                if ( _alt==1 ) {
3249                                        {
3250                                        setState(506);
3251                                        _errHandler.sync(this);
3252                                        switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
3253                                        case 1:
3254                                                {
3255                                                setState(469);
3256                                                htmlTag();
3257                                                }
3258                                                break;
3259                                        case 2:
3260                                                {
3261                                                setState(470);
3262                                                singletonTag();
3263                                                }
3264                                                break;
3265                                        case 3:
3266                                                {
3267                                                setState(471);
3268                                                paragraph();
3269                                                }
3270                                                break;
3271                                        case 4:
3272                                                {
3273                                                setState(472);
3274                                                li();
3275                                                }
3276                                                break;
3277                                        case 5:
3278                                                {
3279                                                setState(473);
3280                                                td();
3281                                                }
3282                                                break;
3283                                        case 6:
3284                                                {
3285                                                setState(474);
3286                                                th();
3287                                                }
3288                                                break;
3289                                        case 7:
3290                                                {
3291                                                setState(475);
3292                                                body();
3293                                                }
3294                                                break;
3295                                        case 8:
3296                                                {
3297                                                setState(476);
3298                                                colgroup();
3299                                                }
3300                                                break;
3301                                        case 9:
3302                                                {
3303                                                setState(477);
3304                                                dd();
3305                                                }
3306                                                break;
3307                                        case 10:
3308                                                {
3309                                                setState(478);
3310                                                dt();
3311                                                }
3312                                                break;
3313                                        case 11:
3314                                                {
3315                                                setState(479);
3316                                                head();
3317                                                }
3318                                                break;
3319                                        case 12:
3320                                                {
3321                                                setState(480);
3322                                                html();
3323                                                }
3324                                                break;
3325                                        case 13:
3326                                                {
3327                                                setState(481);
3328                                                option();
3329                                                }
3330                                                break;
3331                                        case 14:
3332                                                {
3333                                                setState(482);
3334                                                tbody();
3335                                                }
3336                                                break;
3337                                        case 15:
3338                                                {
3339                                                setState(483);
3340                                                thead();
3341                                                }
3342                                                break;
3343                                        case 16:
3344                                                {
3345                                                setState(484);
3346                                                tfoot();
3347                                                }
3348                                                break;
3349                                        case 17:
3350                                                {
3351                                                setState(485);
3352                                                pTagOpen();
3353                                                }
3354                                                break;
3355                                        case 18:
3356                                                {
3357                                                setState(486);
3358                                                liTagOpen();
3359                                                }
3360                                                break;
3361                                        case 19:
3362                                                {
3363                                                setState(487);
3364                                                tdTagOpen();
3365                                                }
3366                                                break;
3367                                        case 20:
3368                                                {
3369                                                setState(488);
3370                                                thTagOpen();
3371                                                }
3372                                                break;
3373                                        case 21:
3374                                                {
3375                                                setState(489);
3376                                                bodyTagOpen();
3377                                                }
3378                                                break;
3379                                        case 22:
3380                                                {
3381                                                setState(490);
3382                                                colgroupTagOpen();
3383                                                }
3384                                                break;
3385                                        case 23:
3386                                                {
3387                                                setState(491);
3388                                                ddTagOpen();
3389                                                }
3390                                                break;
3391                                        case 24:
3392                                                {
3393                                                setState(492);
3394                                                dtTagOpen();
3395                                                }
3396                                                break;
3397                                        case 25:
3398                                                {
3399                                                setState(493);
3400                                                headTagOpen();
3401                                                }
3402                                                break;
3403                                        case 26:
3404                                                {
3405                                                setState(494);
3406                                                htmlTagOpen();
3407                                                }
3408                                                break;
3409                                        case 27:
3410                                                {
3411                                                setState(495);
3412                                                optionTagOpen();
3413                                                }
3414                                                break;
3415                                        case 28:
3416                                                {
3417                                                setState(496);
3418                                                tbodyTagOpen();
3419                                                }
3420                                                break;
3421                                        case 29:
3422                                                {
3423                                                setState(497);
3424                                                theadTagOpen();
3425                                                }
3426                                                break;
3427                                        case 30:
3428                                                {
3429                                                setState(498);
3430                                                tfootTagOpen();
3431                                                }
3432                                                break;
3433                                        case 31:
3434                                                {
3435                                                {
3436                                                setState(499);
3437                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3438                                                setState(500);
3439                                                match(LEADING_ASTERISK);
3440                                                }
3441                                                }
3442                                                break;
3443                                        case 32:
3444                                                {
3445                                                setState(501);
3446                                                htmlComment();
3447                                                }
3448                                                break;
3449                                        case 33:
3450                                                {
3451                                                setState(502);
3452                                                match(CDATA);
3453                                                }
3454                                                break;
3455                                        case 34:
3456                                                {
3457                                                setState(503);
3458                                                match(NEWLINE);
3459                                                }
3460                                                break;
3461                                        case 35:
3462                                                {
3463                                                setState(504);
3464                                                text();
3465                                                }
3466                                                break;
3467                                        case 36:
3468                                                {
3469                                                setState(505);
3470                                                javadocInlineTag();
3471                                                }
3472                                                break;
3473                                        }
3474                                        } 
3475                                }
3476                                setState(510);
3477                                _errHandler.sync(this);
3478                                _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3479                        }
3480                        setState(511);
3481                        trTagClose();
3482                        }
3483                }
3484                catch (RecognitionException re) {
3485                        _localctx.exception = re;
3486                        _errHandler.reportError(this, re);
3487                        _errHandler.recover(this, re);
3488                }
3489                finally {
3490                        exitRule();
3491                }
3492                return _localctx;
3493        }
3494
3495        public static class TdTagOpenContext extends ParserRuleContext {
3496                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3497                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3498                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3499                public List<AttributeContext> attribute() {
3500                        return getRuleContexts(AttributeContext.class);
3501                }
3502                public AttributeContext attribute(int i) {
3503                        return getRuleContext(AttributeContext.class,i);
3504                }
3505                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3506                public TerminalNode NEWLINE(int i) {
3507                        return getToken(JavadocParser.NEWLINE, i);
3508                }
3509                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3510                public TerminalNode LEADING_ASTERISK(int i) {
3511                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3512                }
3513                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3514                public TerminalNode WS(int i) {
3515                        return getToken(JavadocParser.WS, i);
3516                }
3517                public TdTagOpenContext(ParserRuleContext parent, int invokingState) {
3518                        super(parent, invokingState);
3519                }
3520                @Override public int getRuleIndex() { return RULE_tdTagOpen; }
3521                @Override
3522                public void enterRule(ParseTreeListener listener) {
3523                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this);
3524                }
3525                @Override
3526                public void exitRule(ParseTreeListener listener) {
3527                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this);
3528                }
3529                @Override
3530                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3531                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this);
3532                        else return visitor.visitChildren(this);
3533                }
3534        }
3535
3536        public final TdTagOpenContext tdTagOpen() throws RecognitionException {
3537                TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState());
3538                enterRule(_localctx, 30, RULE_tdTagOpen);
3539                int _la;
3540                try {
3541                        enterOuterAlt(_localctx, 1);
3542                        {
3543                        setState(513);
3544                        match(OPEN);
3545                        setState(514);
3546                        match(TD_HTML_TAG_NAME);
3547                        setState(521);
3548                        _errHandler.sync(this);
3549                        _la = _input.LA(1);
3550                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3551                                {
3552                                setState(519);
3553                                switch (_input.LA(1)) {
3554                                case HTML_TAG_NAME:
3555                                        {
3556                                        setState(515);
3557                                        attribute();
3558                                        }
3559                                        break;
3560                                case NEWLINE:
3561                                        {
3562                                        setState(516);
3563                                        match(NEWLINE);
3564                                        }
3565                                        break;
3566                                case LEADING_ASTERISK:
3567                                        {
3568                                        setState(517);
3569                                        match(LEADING_ASTERISK);
3570                                        }
3571                                        break;
3572                                case WS:
3573                                        {
3574                                        setState(518);
3575                                        match(WS);
3576                                        }
3577                                        break;
3578                                default:
3579                                        throw new NoViableAltException(this);
3580                                }
3581                                }
3582                                setState(523);
3583                                _errHandler.sync(this);
3584                                _la = _input.LA(1);
3585                        }
3586                        setState(524);
3587                        match(CLOSE);
3588                        }
3589                }
3590                catch (RecognitionException re) {
3591                        _localctx.exception = re;
3592                        _errHandler.reportError(this, re);
3593                        _errHandler.recover(this, re);
3594                }
3595                finally {
3596                        exitRule();
3597                }
3598                return _localctx;
3599        }
3600
3601        public static class TdTagCloseContext extends ParserRuleContext {
3602                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3603                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3604                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3605                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3606                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3607                public TerminalNode NEWLINE(int i) {
3608                        return getToken(JavadocParser.NEWLINE, i);
3609                }
3610                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3611                public TerminalNode LEADING_ASTERISK(int i) {
3612                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3613                }
3614                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3615                public TerminalNode WS(int i) {
3616                        return getToken(JavadocParser.WS, i);
3617                }
3618                public TdTagCloseContext(ParserRuleContext parent, int invokingState) {
3619                        super(parent, invokingState);
3620                }
3621                @Override public int getRuleIndex() { return RULE_tdTagClose; }
3622                @Override
3623                public void enterRule(ParseTreeListener listener) {
3624                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this);
3625                }
3626                @Override
3627                public void exitRule(ParseTreeListener listener) {
3628                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this);
3629                }
3630                @Override
3631                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3632                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this);
3633                        else return visitor.visitChildren(this);
3634                }
3635        }
3636
3637        public final TdTagCloseContext tdTagClose() throws RecognitionException {
3638                TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState());
3639                enterRule(_localctx, 32, RULE_tdTagClose);
3640                int _la;
3641                try {
3642                        enterOuterAlt(_localctx, 1);
3643                        {
3644                        setState(526);
3645                        match(OPEN);
3646                        setState(527);
3647                        match(SLASH);
3648                        setState(528);
3649                        match(TD_HTML_TAG_NAME);
3650                        setState(532);
3651                        _errHandler.sync(this);
3652                        _la = _input.LA(1);
3653                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3654                                {
3655                                {
3656                                setState(529);
3657                                _la = _input.LA(1);
3658                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3659                                _errHandler.recoverInline(this);
3660                                } else {
3661                                        consume();
3662                                }
3663                                }
3664                                }
3665                                setState(534);
3666                                _errHandler.sync(this);
3667                                _la = _input.LA(1);
3668                        }
3669                        setState(535);
3670                        match(CLOSE);
3671                        }
3672                }
3673                catch (RecognitionException re) {
3674                        _localctx.exception = re;
3675                        _errHandler.reportError(this, re);
3676                        _errHandler.recover(this, re);
3677                }
3678                finally {
3679                        exitRule();
3680                }
3681                return _localctx;
3682        }
3683
3684        public static class TdContext extends ParserRuleContext {
3685                public List<TdTagOpenContext> tdTagOpen() {
3686                        return getRuleContexts(TdTagOpenContext.class);
3687                }
3688                public TdTagOpenContext tdTagOpen(int i) {
3689                        return getRuleContext(TdTagOpenContext.class,i);
3690                }
3691                public TdTagCloseContext tdTagClose() {
3692                        return getRuleContext(TdTagCloseContext.class,0);
3693                }
3694                public List<HtmlTagContext> htmlTag() {
3695                        return getRuleContexts(HtmlTagContext.class);
3696                }
3697                public HtmlTagContext htmlTag(int i) {
3698                        return getRuleContext(HtmlTagContext.class,i);
3699                }
3700                public List<SingletonTagContext> singletonTag() {
3701                        return getRuleContexts(SingletonTagContext.class);
3702                }
3703                public SingletonTagContext singletonTag(int i) {
3704                        return getRuleContext(SingletonTagContext.class,i);
3705                }
3706                public List<ParagraphContext> paragraph() {
3707                        return getRuleContexts(ParagraphContext.class);
3708                }
3709                public ParagraphContext paragraph(int i) {
3710                        return getRuleContext(ParagraphContext.class,i);
3711                }
3712                public List<LiContext> li() {
3713                        return getRuleContexts(LiContext.class);
3714                }
3715                public LiContext li(int i) {
3716                        return getRuleContext(LiContext.class,i);
3717                }
3718                public List<TrContext> tr() {
3719                        return getRuleContexts(TrContext.class);
3720                }
3721                public TrContext tr(int i) {
3722                        return getRuleContext(TrContext.class,i);
3723                }
3724                public List<ThContext> th() {
3725                        return getRuleContexts(ThContext.class);
3726                }
3727                public ThContext th(int i) {
3728                        return getRuleContext(ThContext.class,i);
3729                }
3730                public List<BodyContext> body() {
3731                        return getRuleContexts(BodyContext.class);
3732                }
3733                public BodyContext body(int i) {
3734                        return getRuleContext(BodyContext.class,i);
3735                }
3736                public List<ColgroupContext> colgroup() {
3737                        return getRuleContexts(ColgroupContext.class);
3738                }
3739                public ColgroupContext colgroup(int i) {
3740                        return getRuleContext(ColgroupContext.class,i);
3741                }
3742                public List<DdContext> dd() {
3743                        return getRuleContexts(DdContext.class);
3744                }
3745                public DdContext dd(int i) {
3746                        return getRuleContext(DdContext.class,i);
3747                }
3748                public List<DtContext> dt() {
3749                        return getRuleContexts(DtContext.class);
3750                }
3751                public DtContext dt(int i) {
3752                        return getRuleContext(DtContext.class,i);
3753                }
3754                public List<HeadContext> head() {
3755                        return getRuleContexts(HeadContext.class);
3756                }
3757                public HeadContext head(int i) {
3758                        return getRuleContext(HeadContext.class,i);
3759                }
3760                public List<HtmlContext> html() {
3761                        return getRuleContexts(HtmlContext.class);
3762                }
3763                public HtmlContext html(int i) {
3764                        return getRuleContext(HtmlContext.class,i);
3765                }
3766                public List<OptionContext> option() {
3767                        return getRuleContexts(OptionContext.class);
3768                }
3769                public OptionContext option(int i) {
3770                        return getRuleContext(OptionContext.class,i);
3771                }
3772                public List<TbodyContext> tbody() {
3773                        return getRuleContexts(TbodyContext.class);
3774                }
3775                public TbodyContext tbody(int i) {
3776                        return getRuleContext(TbodyContext.class,i);
3777                }
3778                public List<TheadContext> thead() {
3779                        return getRuleContexts(TheadContext.class);
3780                }
3781                public TheadContext thead(int i) {
3782                        return getRuleContext(TheadContext.class,i);
3783                }
3784                public List<TfootContext> tfoot() {
3785                        return getRuleContexts(TfootContext.class);
3786                }
3787                public TfootContext tfoot(int i) {
3788                        return getRuleContext(TfootContext.class,i);
3789                }
3790                public List<PTagOpenContext> pTagOpen() {
3791                        return getRuleContexts(PTagOpenContext.class);
3792                }
3793                public PTagOpenContext pTagOpen(int i) {
3794                        return getRuleContext(PTagOpenContext.class,i);
3795                }
3796                public List<LiTagOpenContext> liTagOpen() {
3797                        return getRuleContexts(LiTagOpenContext.class);
3798                }
3799                public LiTagOpenContext liTagOpen(int i) {
3800                        return getRuleContext(LiTagOpenContext.class,i);
3801                }
3802                public List<ThTagOpenContext> thTagOpen() {
3803                        return getRuleContexts(ThTagOpenContext.class);
3804                }
3805                public ThTagOpenContext thTagOpen(int i) {
3806                        return getRuleContext(ThTagOpenContext.class,i);
3807                }
3808                public List<BodyTagOpenContext> bodyTagOpen() {
3809                        return getRuleContexts(BodyTagOpenContext.class);
3810                }
3811                public BodyTagOpenContext bodyTagOpen(int i) {
3812                        return getRuleContext(BodyTagOpenContext.class,i);
3813                }
3814                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3815                        return getRuleContexts(ColgroupTagOpenContext.class);
3816                }
3817                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3818                        return getRuleContext(ColgroupTagOpenContext.class,i);
3819                }
3820                public List<DdTagOpenContext> ddTagOpen() {
3821                        return getRuleContexts(DdTagOpenContext.class);
3822                }
3823                public DdTagOpenContext ddTagOpen(int i) {
3824                        return getRuleContext(DdTagOpenContext.class,i);
3825                }
3826                public List<DtTagOpenContext> dtTagOpen() {
3827                        return getRuleContexts(DtTagOpenContext.class);
3828                }
3829                public DtTagOpenContext dtTagOpen(int i) {
3830                        return getRuleContext(DtTagOpenContext.class,i);
3831                }
3832                public List<HeadTagOpenContext> headTagOpen() {
3833                        return getRuleContexts(HeadTagOpenContext.class);
3834                }
3835                public HeadTagOpenContext headTagOpen(int i) {
3836                        return getRuleContext(HeadTagOpenContext.class,i);
3837                }
3838                public List<HtmlTagOpenContext> htmlTagOpen() {
3839                        return getRuleContexts(HtmlTagOpenContext.class);
3840                }
3841                public HtmlTagOpenContext htmlTagOpen(int i) {
3842                        return getRuleContext(HtmlTagOpenContext.class,i);
3843                }
3844                public List<OptionTagOpenContext> optionTagOpen() {
3845                        return getRuleContexts(OptionTagOpenContext.class);
3846                }
3847                public OptionTagOpenContext optionTagOpen(int i) {
3848                        return getRuleContext(OptionTagOpenContext.class,i);
3849                }
3850                public List<TbodyTagOpenContext> tbodyTagOpen() {
3851                        return getRuleContexts(TbodyTagOpenContext.class);
3852                }
3853                public TbodyTagOpenContext tbodyTagOpen(int i) {
3854                        return getRuleContext(TbodyTagOpenContext.class,i);
3855                }
3856                public List<TheadTagOpenContext> theadTagOpen() {
3857                        return getRuleContexts(TheadTagOpenContext.class);
3858                }
3859                public TheadTagOpenContext theadTagOpen(int i) {
3860                        return getRuleContext(TheadTagOpenContext.class,i);
3861                }
3862                public List<TfootTagOpenContext> tfootTagOpen() {
3863                        return getRuleContexts(TfootTagOpenContext.class);
3864                }
3865                public TfootTagOpenContext tfootTagOpen(int i) {
3866                        return getRuleContext(TfootTagOpenContext.class,i);
3867                }
3868                public List<HtmlCommentContext> htmlComment() {
3869                        return getRuleContexts(HtmlCommentContext.class);
3870                }
3871                public HtmlCommentContext htmlComment(int i) {
3872                        return getRuleContext(HtmlCommentContext.class,i);
3873                }
3874                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3875                public TerminalNode CDATA(int i) {
3876                        return getToken(JavadocParser.CDATA, i);
3877                }
3878                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3879                public TerminalNode NEWLINE(int i) {
3880                        return getToken(JavadocParser.NEWLINE, i);
3881                }
3882                public List<TextContext> text() {
3883                        return getRuleContexts(TextContext.class);
3884                }
3885                public TextContext text(int i) {
3886                        return getRuleContext(TextContext.class,i);
3887                }
3888                public List<JavadocInlineTagContext> javadocInlineTag() {
3889                        return getRuleContexts(JavadocInlineTagContext.class);
3890                }
3891                public JavadocInlineTagContext javadocInlineTag(int i) {
3892                        return getRuleContext(JavadocInlineTagContext.class,i);
3893                }
3894                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3895                public TerminalNode LEADING_ASTERISK(int i) {
3896                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3897                }
3898                public TdContext(ParserRuleContext parent, int invokingState) {
3899                        super(parent, invokingState);
3900                }
3901                @Override public int getRuleIndex() { return RULE_td; }
3902                @Override
3903                public void enterRule(ParseTreeListener listener) {
3904                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this);
3905                }
3906                @Override
3907                public void exitRule(ParseTreeListener listener) {
3908                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this);
3909                }
3910                @Override
3911                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3912                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this);
3913                        else return visitor.visitChildren(this);
3914                }
3915        }
3916
3917        public final TdContext td() throws RecognitionException {
3918                TdContext _localctx = new TdContext(_ctx, getState());
3919                enterRule(_localctx, 34, RULE_td);
3920                try {
3921                        int _alt;
3922                        enterOuterAlt(_localctx, 1);
3923                        {
3924                        setState(537);
3925                        tdTagOpen();
3926                        setState(577);
3927                        _errHandler.sync(this);
3928                        _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
3929                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3930                                if ( _alt==1 ) {
3931                                        {
3932                                        setState(575);
3933                                        _errHandler.sync(this);
3934                                        switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
3935                                        case 1:
3936                                                {
3937                                                setState(538);
3938                                                htmlTag();
3939                                                }
3940                                                break;
3941                                        case 2:
3942                                                {
3943                                                setState(539);
3944                                                singletonTag();
3945                                                }
3946                                                break;
3947                                        case 3:
3948                                                {
3949                                                setState(540);
3950                                                paragraph();
3951                                                }
3952                                                break;
3953                                        case 4:
3954                                                {
3955                                                setState(541);
3956                                                li();
3957                                                }
3958                                                break;
3959                                        case 5:
3960                                                {
3961                                                setState(542);
3962                                                tr();
3963                                                }
3964                                                break;
3965                                        case 6:
3966                                                {
3967                                                setState(543);
3968                                                th();
3969                                                }
3970                                                break;
3971                                        case 7:
3972                                                {
3973                                                setState(544);
3974                                                body();
3975                                                }
3976                                                break;
3977                                        case 8:
3978                                                {
3979                                                setState(545);
3980                                                colgroup();
3981                                                }
3982                                                break;
3983                                        case 9:
3984                                                {
3985                                                setState(546);
3986                                                dd();
3987                                                }
3988                                                break;
3989                                        case 10:
3990                                                {
3991                                                setState(547);
3992                                                dt();
3993                                                }
3994                                                break;
3995                                        case 11:
3996                                                {
3997                                                setState(548);
3998                                                head();
3999                                                }
4000                                                break;
4001                                        case 12:
4002                                                {
4003                                                setState(549);
4004                                                html();
4005                                                }
4006                                                break;
4007                                        case 13:
4008                                                {
4009                                                setState(550);
4010                                                option();
4011                                                }
4012                                                break;
4013                                        case 14:
4014                                                {
4015                                                setState(551);
4016                                                tbody();
4017                                                }
4018                                                break;
4019                                        case 15:
4020                                                {
4021                                                setState(552);
4022                                                thead();
4023                                                }
4024                                                break;
4025                                        case 16:
4026                                                {
4027                                                setState(553);
4028                                                tfoot();
4029                                                }
4030                                                break;
4031                                        case 17:
4032                                                {
4033                                                setState(554);
4034                                                pTagOpen();
4035                                                }
4036                                                break;
4037                                        case 18:
4038                                                {
4039                                                setState(555);
4040                                                liTagOpen();
4041                                                }
4042                                                break;
4043                                        case 19:
4044                                                {
4045                                                setState(556);
4046                                                tdTagOpen();
4047                                                }
4048                                                break;
4049                                        case 20:
4050                                                {
4051                                                setState(557);
4052                                                thTagOpen();
4053                                                }
4054                                                break;
4055                                        case 21:
4056                                                {
4057                                                setState(558);
4058                                                bodyTagOpen();
4059                                                }
4060                                                break;
4061                                        case 22:
4062                                                {
4063                                                setState(559);
4064                                                colgroupTagOpen();
4065                                                }
4066                                                break;
4067                                        case 23:
4068                                                {
4069                                                setState(560);
4070                                                ddTagOpen();
4071                                                }
4072                                                break;
4073                                        case 24:
4074                                                {
4075                                                setState(561);
4076                                                dtTagOpen();
4077                                                }
4078                                                break;
4079                                        case 25:
4080                                                {
4081                                                setState(562);
4082                                                headTagOpen();
4083                                                }
4084                                                break;
4085                                        case 26:
4086                                                {
4087                                                setState(563);
4088                                                htmlTagOpen();
4089                                                }
4090                                                break;
4091                                        case 27:
4092                                                {
4093                                                setState(564);
4094                                                optionTagOpen();
4095                                                }
4096                                                break;
4097                                        case 28:
4098                                                {
4099                                                setState(565);
4100                                                tbodyTagOpen();
4101                                                }
4102                                                break;
4103                                        case 29:
4104                                                {
4105                                                setState(566);
4106                                                theadTagOpen();
4107                                                }
4108                                                break;
4109                                        case 30:
4110                                                {
4111                                                setState(567);
4112                                                tfootTagOpen();
4113                                                }
4114                                                break;
4115                                        case 31:
4116                                                {
4117                                                {
4118                                                setState(568);
4119                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4120                                                setState(569);
4121                                                match(LEADING_ASTERISK);
4122                                                }
4123                                                }
4124                                                break;
4125                                        case 32:
4126                                                {
4127                                                setState(570);
4128                                                htmlComment();
4129                                                }
4130                                                break;
4131                                        case 33:
4132                                                {
4133                                                setState(571);
4134                                                match(CDATA);
4135                                                }
4136                                                break;
4137                                        case 34:
4138                                                {
4139                                                setState(572);
4140                                                match(NEWLINE);
4141                                                }
4142                                                break;
4143                                        case 35:
4144                                                {
4145                                                setState(573);
4146                                                text();
4147                                                }
4148                                                break;
4149                                        case 36:
4150                                                {
4151                                                setState(574);
4152                                                javadocInlineTag();
4153                                                }
4154                                                break;
4155                                        }
4156                                        } 
4157                                }
4158                                setState(579);
4159                                _errHandler.sync(this);
4160                                _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
4161                        }
4162                        setState(580);
4163                        tdTagClose();
4164                        }
4165                }
4166                catch (RecognitionException re) {
4167                        _localctx.exception = re;
4168                        _errHandler.reportError(this, re);
4169                        _errHandler.recover(this, re);
4170                }
4171                finally {
4172                        exitRule();
4173                }
4174                return _localctx;
4175        }
4176
4177        public static class ThTagOpenContext extends ParserRuleContext {
4178                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4179                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4180                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4181                public List<AttributeContext> attribute() {
4182                        return getRuleContexts(AttributeContext.class);
4183                }
4184                public AttributeContext attribute(int i) {
4185                        return getRuleContext(AttributeContext.class,i);
4186                }
4187                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4188                public TerminalNode NEWLINE(int i) {
4189                        return getToken(JavadocParser.NEWLINE, i);
4190                }
4191                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4192                public TerminalNode LEADING_ASTERISK(int i) {
4193                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4194                }
4195                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4196                public TerminalNode WS(int i) {
4197                        return getToken(JavadocParser.WS, i);
4198                }
4199                public ThTagOpenContext(ParserRuleContext parent, int invokingState) {
4200                        super(parent, invokingState);
4201                }
4202                @Override public int getRuleIndex() { return RULE_thTagOpen; }
4203                @Override
4204                public void enterRule(ParseTreeListener listener) {
4205                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this);
4206                }
4207                @Override
4208                public void exitRule(ParseTreeListener listener) {
4209                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this);
4210                }
4211                @Override
4212                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4213                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this);
4214                        else return visitor.visitChildren(this);
4215                }
4216        }
4217
4218        public final ThTagOpenContext thTagOpen() throws RecognitionException {
4219                ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState());
4220                enterRule(_localctx, 36, RULE_thTagOpen);
4221                int _la;
4222                try {
4223                        enterOuterAlt(_localctx, 1);
4224                        {
4225                        setState(582);
4226                        match(OPEN);
4227                        setState(583);
4228                        match(TH_HTML_TAG_NAME);
4229                        setState(590);
4230                        _errHandler.sync(this);
4231                        _la = _input.LA(1);
4232                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4233                                {
4234                                setState(588);
4235                                switch (_input.LA(1)) {
4236                                case HTML_TAG_NAME:
4237                                        {
4238                                        setState(584);
4239                                        attribute();
4240                                        }
4241                                        break;
4242                                case NEWLINE:
4243                                        {
4244                                        setState(585);
4245                                        match(NEWLINE);
4246                                        }
4247                                        break;
4248                                case LEADING_ASTERISK:
4249                                        {
4250                                        setState(586);
4251                                        match(LEADING_ASTERISK);
4252                                        }
4253                                        break;
4254                                case WS:
4255                                        {
4256                                        setState(587);
4257                                        match(WS);
4258                                        }
4259                                        break;
4260                                default:
4261                                        throw new NoViableAltException(this);
4262                                }
4263                                }
4264                                setState(592);
4265                                _errHandler.sync(this);
4266                                _la = _input.LA(1);
4267                        }
4268                        setState(593);
4269                        match(CLOSE);
4270                        }
4271                }
4272                catch (RecognitionException re) {
4273                        _localctx.exception = re;
4274                        _errHandler.reportError(this, re);
4275                        _errHandler.recover(this, re);
4276                }
4277                finally {
4278                        exitRule();
4279                }
4280                return _localctx;
4281        }
4282
4283        public static class ThTagCloseContext extends ParserRuleContext {
4284                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4285                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4286                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4287                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4288                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4289                public TerminalNode NEWLINE(int i) {
4290                        return getToken(JavadocParser.NEWLINE, i);
4291                }
4292                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4293                public TerminalNode LEADING_ASTERISK(int i) {
4294                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4295                }
4296                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4297                public TerminalNode WS(int i) {
4298                        return getToken(JavadocParser.WS, i);
4299                }
4300                public ThTagCloseContext(ParserRuleContext parent, int invokingState) {
4301                        super(parent, invokingState);
4302                }
4303                @Override public int getRuleIndex() { return RULE_thTagClose; }
4304                @Override
4305                public void enterRule(ParseTreeListener listener) {
4306                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this);
4307                }
4308                @Override
4309                public void exitRule(ParseTreeListener listener) {
4310                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this);
4311                }
4312                @Override
4313                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4314                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this);
4315                        else return visitor.visitChildren(this);
4316                }
4317        }
4318
4319        public final ThTagCloseContext thTagClose() throws RecognitionException {
4320                ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState());
4321                enterRule(_localctx, 38, RULE_thTagClose);
4322                int _la;
4323                try {
4324                        enterOuterAlt(_localctx, 1);
4325                        {
4326                        setState(595);
4327                        match(OPEN);
4328                        setState(596);
4329                        match(SLASH);
4330                        setState(597);
4331                        match(TH_HTML_TAG_NAME);
4332                        setState(601);
4333                        _errHandler.sync(this);
4334                        _la = _input.LA(1);
4335                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4336                                {
4337                                {
4338                                setState(598);
4339                                _la = _input.LA(1);
4340                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4341                                _errHandler.recoverInline(this);
4342                                } else {
4343                                        consume();
4344                                }
4345                                }
4346                                }
4347                                setState(603);
4348                                _errHandler.sync(this);
4349                                _la = _input.LA(1);
4350                        }
4351                        setState(604);
4352                        match(CLOSE);
4353                        }
4354                }
4355                catch (RecognitionException re) {
4356                        _localctx.exception = re;
4357                        _errHandler.reportError(this, re);
4358                        _errHandler.recover(this, re);
4359                }
4360                finally {
4361                        exitRule();
4362                }
4363                return _localctx;
4364        }
4365
4366        public static class ThContext extends ParserRuleContext {
4367                public ThTagOpenContext thTagOpen() {
4368                        return getRuleContext(ThTagOpenContext.class,0);
4369                }
4370                public ThTagCloseContext thTagClose() {
4371                        return getRuleContext(ThTagCloseContext.class,0);
4372                }
4373                public List<HtmlTagContext> htmlTag() {
4374                        return getRuleContexts(HtmlTagContext.class);
4375                }
4376                public HtmlTagContext htmlTag(int i) {
4377                        return getRuleContext(HtmlTagContext.class,i);
4378                }
4379                public List<SingletonTagContext> singletonTag() {
4380                        return getRuleContexts(SingletonTagContext.class);
4381                }
4382                public SingletonTagContext singletonTag(int i) {
4383                        return getRuleContext(SingletonTagContext.class,i);
4384                }
4385                public List<ParagraphContext> paragraph() {
4386                        return getRuleContexts(ParagraphContext.class);
4387                }
4388                public ParagraphContext paragraph(int i) {
4389                        return getRuleContext(ParagraphContext.class,i);
4390                }
4391                public List<LiContext> li() {
4392                        return getRuleContexts(LiContext.class);
4393                }
4394                public LiContext li(int i) {
4395                        return getRuleContext(LiContext.class,i);
4396                }
4397                public List<TrContext> tr() {
4398                        return getRuleContexts(TrContext.class);
4399                }
4400                public TrContext tr(int i) {
4401                        return getRuleContext(TrContext.class,i);
4402                }
4403                public List<TdContext> td() {
4404                        return getRuleContexts(TdContext.class);
4405                }
4406                public TdContext td(int i) {
4407                        return getRuleContext(TdContext.class,i);
4408                }
4409                public List<BodyContext> body() {
4410                        return getRuleContexts(BodyContext.class);
4411                }
4412                public BodyContext body(int i) {
4413                        return getRuleContext(BodyContext.class,i);
4414                }
4415                public List<ColgroupContext> colgroup() {
4416                        return getRuleContexts(ColgroupContext.class);
4417                }
4418                public ColgroupContext colgroup(int i) {
4419                        return getRuleContext(ColgroupContext.class,i);
4420                }
4421                public List<DdContext> dd() {
4422                        return getRuleContexts(DdContext.class);
4423                }
4424                public DdContext dd(int i) {
4425                        return getRuleContext(DdContext.class,i);
4426                }
4427                public List<DtContext> dt() {
4428                        return getRuleContexts(DtContext.class);
4429                }
4430                public DtContext dt(int i) {
4431                        return getRuleContext(DtContext.class,i);
4432                }
4433                public List<HeadContext> head() {
4434                        return getRuleContexts(HeadContext.class);
4435                }
4436                public HeadContext head(int i) {
4437                        return getRuleContext(HeadContext.class,i);
4438                }
4439                public List<HtmlContext> html() {
4440                        return getRuleContexts(HtmlContext.class);
4441                }
4442                public HtmlContext html(int i) {
4443                        return getRuleContext(HtmlContext.class,i);
4444                }
4445                public List<OptionContext> option() {
4446                        return getRuleContexts(OptionContext.class);
4447                }
4448                public OptionContext option(int i) {
4449                        return getRuleContext(OptionContext.class,i);
4450                }
4451                public List<TbodyContext> tbody() {
4452                        return getRuleContexts(TbodyContext.class);
4453                }
4454                public TbodyContext tbody(int i) {
4455                        return getRuleContext(TbodyContext.class,i);
4456                }
4457                public List<TheadContext> thead() {
4458                        return getRuleContexts(TheadContext.class);
4459                }
4460                public TheadContext thead(int i) {
4461                        return getRuleContext(TheadContext.class,i);
4462                }
4463                public List<TfootContext> tfoot() {
4464                        return getRuleContexts(TfootContext.class);
4465                }
4466                public TfootContext tfoot(int i) {
4467                        return getRuleContext(TfootContext.class,i);
4468                }
4469                public List<PTagOpenContext> pTagOpen() {
4470                        return getRuleContexts(PTagOpenContext.class);
4471                }
4472                public PTagOpenContext pTagOpen(int i) {
4473                        return getRuleContext(PTagOpenContext.class,i);
4474                }
4475                public List<LiTagOpenContext> liTagOpen() {
4476                        return getRuleContexts(LiTagOpenContext.class);
4477                }
4478                public LiTagOpenContext liTagOpen(int i) {
4479                        return getRuleContext(LiTagOpenContext.class,i);
4480                }
4481                public List<TrTagOpenContext> trTagOpen() {
4482                        return getRuleContexts(TrTagOpenContext.class);
4483                }
4484                public TrTagOpenContext trTagOpen(int i) {
4485                        return getRuleContext(TrTagOpenContext.class,i);
4486                }
4487                public List<TdTagOpenContext> tdTagOpen() {
4488                        return getRuleContexts(TdTagOpenContext.class);
4489                }
4490                public TdTagOpenContext tdTagOpen(int i) {
4491                        return getRuleContext(TdTagOpenContext.class,i);
4492                }
4493                public List<BodyTagOpenContext> bodyTagOpen() {
4494                        return getRuleContexts(BodyTagOpenContext.class);
4495                }
4496                public BodyTagOpenContext bodyTagOpen(int i) {
4497                        return getRuleContext(BodyTagOpenContext.class,i);
4498                }
4499                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4500                        return getRuleContexts(ColgroupTagOpenContext.class);
4501                }
4502                public ColgroupTagOpenContext colgroupTagOpen(int i) {
4503                        return getRuleContext(ColgroupTagOpenContext.class,i);
4504                }
4505                public List<DdTagOpenContext> ddTagOpen() {
4506                        return getRuleContexts(DdTagOpenContext.class);
4507                }
4508                public DdTagOpenContext ddTagOpen(int i) {
4509                        return getRuleContext(DdTagOpenContext.class,i);
4510                }
4511                public List<DtTagOpenContext> dtTagOpen() {
4512                        return getRuleContexts(DtTagOpenContext.class);
4513                }
4514                public DtTagOpenContext dtTagOpen(int i) {
4515                        return getRuleContext(DtTagOpenContext.class,i);
4516                }
4517                public List<HeadTagOpenContext> headTagOpen() {
4518                        return getRuleContexts(HeadTagOpenContext.class);
4519                }
4520                public HeadTagOpenContext headTagOpen(int i) {
4521                        return getRuleContext(HeadTagOpenContext.class,i);
4522                }
4523                public List<HtmlTagOpenContext> htmlTagOpen() {
4524                        return getRuleContexts(HtmlTagOpenContext.class);
4525                }
4526                public HtmlTagOpenContext htmlTagOpen(int i) {
4527                        return getRuleContext(HtmlTagOpenContext.class,i);
4528                }
4529                public List<OptionTagOpenContext> optionTagOpen() {
4530                        return getRuleContexts(OptionTagOpenContext.class);
4531                }
4532                public OptionTagOpenContext optionTagOpen(int i) {
4533                        return getRuleContext(OptionTagOpenContext.class,i);
4534                }
4535                public List<TbodyTagOpenContext> tbodyTagOpen() {
4536                        return getRuleContexts(TbodyTagOpenContext.class);
4537                }
4538                public TbodyTagOpenContext tbodyTagOpen(int i) {
4539                        return getRuleContext(TbodyTagOpenContext.class,i);
4540                }
4541                public List<TheadTagOpenContext> theadTagOpen() {
4542                        return getRuleContexts(TheadTagOpenContext.class);
4543                }
4544                public TheadTagOpenContext theadTagOpen(int i) {
4545                        return getRuleContext(TheadTagOpenContext.class,i);
4546                }
4547                public List<TfootTagOpenContext> tfootTagOpen() {
4548                        return getRuleContexts(TfootTagOpenContext.class);
4549                }
4550                public TfootTagOpenContext tfootTagOpen(int i) {
4551                        return getRuleContext(TfootTagOpenContext.class,i);
4552                }
4553                public List<HtmlCommentContext> htmlComment() {
4554                        return getRuleContexts(HtmlCommentContext.class);
4555                }
4556                public HtmlCommentContext htmlComment(int i) {
4557                        return getRuleContext(HtmlCommentContext.class,i);
4558                }
4559                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4560                public TerminalNode CDATA(int i) {
4561                        return getToken(JavadocParser.CDATA, i);
4562                }
4563                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4564                public TerminalNode NEWLINE(int i) {
4565                        return getToken(JavadocParser.NEWLINE, i);
4566                }
4567                public List<TextContext> text() {
4568                        return getRuleContexts(TextContext.class);
4569                }
4570                public TextContext text(int i) {
4571                        return getRuleContext(TextContext.class,i);
4572                }
4573                public List<JavadocInlineTagContext> javadocInlineTag() {
4574                        return getRuleContexts(JavadocInlineTagContext.class);
4575                }
4576                public JavadocInlineTagContext javadocInlineTag(int i) {
4577                        return getRuleContext(JavadocInlineTagContext.class,i);
4578                }
4579                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4580                public TerminalNode LEADING_ASTERISK(int i) {
4581                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4582                }
4583                public ThContext(ParserRuleContext parent, int invokingState) {
4584                        super(parent, invokingState);
4585                }
4586                @Override public int getRuleIndex() { return RULE_th; }
4587                @Override
4588                public void enterRule(ParseTreeListener listener) {
4589                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this);
4590                }
4591                @Override
4592                public void exitRule(ParseTreeListener listener) {
4593                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this);
4594                }
4595                @Override
4596                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4597                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this);
4598                        else return visitor.visitChildren(this);
4599                }
4600        }
4601
4602        public final ThContext th() throws RecognitionException {
4603                ThContext _localctx = new ThContext(_ctx, getState());
4604                enterRule(_localctx, 40, RULE_th);
4605                try {
4606                        int _alt;
4607                        enterOuterAlt(_localctx, 1);
4608                        {
4609                        setState(606);
4610                        thTagOpen();
4611                        setState(646);
4612                        _errHandler.sync(this);
4613                        _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4614                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4615                                if ( _alt==1 ) {
4616                                        {
4617                                        setState(644);
4618                                        _errHandler.sync(this);
4619                                        switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
4620                                        case 1:
4621                                                {
4622                                                setState(607);
4623                                                htmlTag();
4624                                                }
4625                                                break;
4626                                        case 2:
4627                                                {
4628                                                setState(608);
4629                                                singletonTag();
4630                                                }
4631                                                break;
4632                                        case 3:
4633                                                {
4634                                                setState(609);
4635                                                paragraph();
4636                                                }
4637                                                break;
4638                                        case 4:
4639                                                {
4640                                                setState(610);
4641                                                li();
4642                                                }
4643                                                break;
4644                                        case 5:
4645                                                {
4646                                                setState(611);
4647                                                tr();
4648                                                }
4649                                                break;
4650                                        case 6:
4651                                                {
4652                                                setState(612);
4653                                                td();
4654                                                }
4655                                                break;
4656                                        case 7:
4657                                                {
4658                                                setState(613);
4659                                                body();
4660                                                }
4661                                                break;
4662                                        case 8:
4663                                                {
4664                                                setState(614);
4665                                                colgroup();
4666                                                }
4667                                                break;
4668                                        case 9:
4669                                                {
4670                                                setState(615);
4671                                                dd();
4672                                                }
4673                                                break;
4674                                        case 10:
4675                                                {
4676                                                setState(616);
4677                                                dt();
4678                                                }
4679                                                break;
4680                                        case 11:
4681                                                {
4682                                                setState(617);
4683                                                head();
4684                                                }
4685                                                break;
4686                                        case 12:
4687                                                {
4688                                                setState(618);
4689                                                html();
4690                                                }
4691                                                break;
4692                                        case 13:
4693                                                {
4694                                                setState(619);
4695                                                option();
4696                                                }
4697                                                break;
4698                                        case 14:
4699                                                {
4700                                                setState(620);
4701                                                tbody();
4702                                                }
4703                                                break;
4704                                        case 15:
4705                                                {
4706                                                setState(621);
4707                                                thead();
4708                                                }
4709                                                break;
4710                                        case 16:
4711                                                {
4712                                                setState(622);
4713                                                tfoot();
4714                                                }
4715                                                break;
4716                                        case 17:
4717                                                {
4718                                                setState(623);
4719                                                pTagOpen();
4720                                                }
4721                                                break;
4722                                        case 18:
4723                                                {
4724                                                setState(624);
4725                                                liTagOpen();
4726                                                }
4727                                                break;
4728                                        case 19:
4729                                                {
4730                                                setState(625);
4731                                                trTagOpen();
4732                                                }
4733                                                break;
4734                                        case 20:
4735                                                {
4736                                                setState(626);
4737                                                tdTagOpen();
4738                                                }
4739                                                break;
4740                                        case 21:
4741                                                {
4742                                                setState(627);
4743                                                bodyTagOpen();
4744                                                }
4745                                                break;
4746                                        case 22:
4747                                                {
4748                                                setState(628);
4749                                                colgroupTagOpen();
4750                                                }
4751                                                break;
4752                                        case 23:
4753                                                {
4754                                                setState(629);
4755                                                ddTagOpen();
4756                                                }
4757                                                break;
4758                                        case 24:
4759                                                {
4760                                                setState(630);
4761                                                dtTagOpen();
4762                                                }
4763                                                break;
4764                                        case 25:
4765                                                {
4766                                                setState(631);
4767                                                headTagOpen();
4768                                                }
4769                                                break;
4770                                        case 26:
4771                                                {
4772                                                setState(632);
4773                                                htmlTagOpen();
4774                                                }
4775                                                break;
4776                                        case 27:
4777                                                {
4778                                                setState(633);
4779                                                optionTagOpen();
4780                                                }
4781                                                break;
4782                                        case 28:
4783                                                {
4784                                                setState(634);
4785                                                tbodyTagOpen();
4786                                                }
4787                                                break;
4788                                        case 29:
4789                                                {
4790                                                setState(635);
4791                                                theadTagOpen();
4792                                                }
4793                                                break;
4794                                        case 30:
4795                                                {
4796                                                setState(636);
4797                                                tfootTagOpen();
4798                                                }
4799                                                break;
4800                                        case 31:
4801                                                {
4802                                                {
4803                                                setState(637);
4804                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4805                                                setState(638);
4806                                                match(LEADING_ASTERISK);
4807                                                }
4808                                                }
4809                                                break;
4810                                        case 32:
4811                                                {
4812                                                setState(639);
4813                                                htmlComment();
4814                                                }
4815                                                break;
4816                                        case 33:
4817                                                {
4818                                                setState(640);
4819                                                match(CDATA);
4820                                                }
4821                                                break;
4822                                        case 34:
4823                                                {
4824                                                setState(641);
4825                                                match(NEWLINE);
4826                                                }
4827                                                break;
4828                                        case 35:
4829                                                {
4830                                                setState(642);
4831                                                text();
4832                                                }
4833                                                break;
4834                                        case 36:
4835                                                {
4836                                                setState(643);
4837                                                javadocInlineTag();
4838                                                }
4839                                                break;
4840                                        }
4841                                        } 
4842                                }
4843                                setState(648);
4844                                _errHandler.sync(this);
4845                                _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4846                        }
4847                        setState(649);
4848                        thTagClose();
4849                        }
4850                }
4851                catch (RecognitionException re) {
4852                        _localctx.exception = re;
4853                        _errHandler.reportError(this, re);
4854                        _errHandler.recover(this, re);
4855                }
4856                finally {
4857                        exitRule();
4858                }
4859                return _localctx;
4860        }
4861
4862        public static class BodyTagOpenContext extends ParserRuleContext {
4863                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4864                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4865                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4866                public List<AttributeContext> attribute() {
4867                        return getRuleContexts(AttributeContext.class);
4868                }
4869                public AttributeContext attribute(int i) {
4870                        return getRuleContext(AttributeContext.class,i);
4871                }
4872                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4873                public TerminalNode NEWLINE(int i) {
4874                        return getToken(JavadocParser.NEWLINE, i);
4875                }
4876                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4877                public TerminalNode LEADING_ASTERISK(int i) {
4878                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4879                }
4880                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4881                public TerminalNode WS(int i) {
4882                        return getToken(JavadocParser.WS, i);
4883                }
4884                public BodyTagOpenContext(ParserRuleContext parent, int invokingState) {
4885                        super(parent, invokingState);
4886                }
4887                @Override public int getRuleIndex() { return RULE_bodyTagOpen; }
4888                @Override
4889                public void enterRule(ParseTreeListener listener) {
4890                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this);
4891                }
4892                @Override
4893                public void exitRule(ParseTreeListener listener) {
4894                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this);
4895                }
4896                @Override
4897                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4898                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this);
4899                        else return visitor.visitChildren(this);
4900                }
4901        }
4902
4903        public final BodyTagOpenContext bodyTagOpen() throws RecognitionException {
4904                BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState());
4905                enterRule(_localctx, 42, RULE_bodyTagOpen);
4906                int _la;
4907                try {
4908                        enterOuterAlt(_localctx, 1);
4909                        {
4910                        setState(651);
4911                        match(OPEN);
4912                        setState(652);
4913                        match(BODY_HTML_TAG_NAME);
4914                        setState(659);
4915                        _errHandler.sync(this);
4916                        _la = _input.LA(1);
4917                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4918                                {
4919                                setState(657);
4920                                switch (_input.LA(1)) {
4921                                case HTML_TAG_NAME:
4922                                        {
4923                                        setState(653);
4924                                        attribute();
4925                                        }
4926                                        break;
4927                                case NEWLINE:
4928                                        {
4929                                        setState(654);
4930                                        match(NEWLINE);
4931                                        }
4932                                        break;
4933                                case LEADING_ASTERISK:
4934                                        {
4935                                        setState(655);
4936                                        match(LEADING_ASTERISK);
4937                                        }
4938                                        break;
4939                                case WS:
4940                                        {
4941                                        setState(656);
4942                                        match(WS);
4943                                        }
4944                                        break;
4945                                default:
4946                                        throw new NoViableAltException(this);
4947                                }
4948                                }
4949                                setState(661);
4950                                _errHandler.sync(this);
4951                                _la = _input.LA(1);
4952                        }
4953                        setState(662);
4954                        match(CLOSE);
4955                        }
4956                }
4957                catch (RecognitionException re) {
4958                        _localctx.exception = re;
4959                        _errHandler.reportError(this, re);
4960                        _errHandler.recover(this, re);
4961                }
4962                finally {
4963                        exitRule();
4964                }
4965                return _localctx;
4966        }
4967
4968        public static class BodyTagCloseContext extends ParserRuleContext {
4969                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4970                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4971                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4972                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4973                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4974                public TerminalNode NEWLINE(int i) {
4975                        return getToken(JavadocParser.NEWLINE, i);
4976                }
4977                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4978                public TerminalNode LEADING_ASTERISK(int i) {
4979                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4980                }
4981                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4982                public TerminalNode WS(int i) {
4983                        return getToken(JavadocParser.WS, i);
4984                }
4985                public BodyTagCloseContext(ParserRuleContext parent, int invokingState) {
4986                        super(parent, invokingState);
4987                }
4988                @Override public int getRuleIndex() { return RULE_bodyTagClose; }
4989                @Override
4990                public void enterRule(ParseTreeListener listener) {
4991                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this);
4992                }
4993                @Override
4994                public void exitRule(ParseTreeListener listener) {
4995                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this);
4996                }
4997                @Override
4998                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4999                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this);
5000                        else return visitor.visitChildren(this);
5001                }
5002        }
5003
5004        public final BodyTagCloseContext bodyTagClose() throws RecognitionException {
5005                BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState());
5006                enterRule(_localctx, 44, RULE_bodyTagClose);
5007                int _la;
5008                try {
5009                        enterOuterAlt(_localctx, 1);
5010                        {
5011                        setState(664);
5012                        match(OPEN);
5013                        setState(665);
5014                        match(SLASH);
5015                        setState(666);
5016                        match(BODY_HTML_TAG_NAME);
5017                        setState(670);
5018                        _errHandler.sync(this);
5019                        _la = _input.LA(1);
5020                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5021                                {
5022                                {
5023                                setState(667);
5024                                _la = _input.LA(1);
5025                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5026                                _errHandler.recoverInline(this);
5027                                } else {
5028                                        consume();
5029                                }
5030                                }
5031                                }
5032                                setState(672);
5033                                _errHandler.sync(this);
5034                                _la = _input.LA(1);
5035                        }
5036                        setState(673);
5037                        match(CLOSE);
5038                        }
5039                }
5040                catch (RecognitionException re) {
5041                        _localctx.exception = re;
5042                        _errHandler.reportError(this, re);
5043                        _errHandler.recover(this, re);
5044                }
5045                finally {
5046                        exitRule();
5047                }
5048                return _localctx;
5049        }
5050
5051        public static class BodyContext extends ParserRuleContext {
5052                public BodyTagOpenContext bodyTagOpen() {
5053                        return getRuleContext(BodyTagOpenContext.class,0);
5054                }
5055                public BodyTagCloseContext bodyTagClose() {
5056                        return getRuleContext(BodyTagCloseContext.class,0);
5057                }
5058                public List<HtmlTagContext> htmlTag() {
5059                        return getRuleContexts(HtmlTagContext.class);
5060                }
5061                public HtmlTagContext htmlTag(int i) {
5062                        return getRuleContext(HtmlTagContext.class,i);
5063                }
5064                public List<SingletonTagContext> singletonTag() {
5065                        return getRuleContexts(SingletonTagContext.class);
5066                }
5067                public SingletonTagContext singletonTag(int i) {
5068                        return getRuleContext(SingletonTagContext.class,i);
5069                }
5070                public List<ParagraphContext> paragraph() {
5071                        return getRuleContexts(ParagraphContext.class);
5072                }
5073                public ParagraphContext paragraph(int i) {
5074                        return getRuleContext(ParagraphContext.class,i);
5075                }
5076                public List<LiContext> li() {
5077                        return getRuleContexts(LiContext.class);
5078                }
5079                public LiContext li(int i) {
5080                        return getRuleContext(LiContext.class,i);
5081                }
5082                public List<TrContext> tr() {
5083                        return getRuleContexts(TrContext.class);
5084                }
5085                public TrContext tr(int i) {
5086                        return getRuleContext(TrContext.class,i);
5087                }
5088                public List<TdContext> td() {
5089                        return getRuleContexts(TdContext.class);
5090                }
5091                public TdContext td(int i) {
5092                        return getRuleContext(TdContext.class,i);
5093                }
5094                public List<ThContext> th() {
5095                        return getRuleContexts(ThContext.class);
5096                }
5097                public ThContext th(int i) {
5098                        return getRuleContext(ThContext.class,i);
5099                }
5100                public List<ColgroupContext> colgroup() {
5101                        return getRuleContexts(ColgroupContext.class);
5102                }
5103                public ColgroupContext colgroup(int i) {
5104                        return getRuleContext(ColgroupContext.class,i);
5105                }
5106                public List<DdContext> dd() {
5107                        return getRuleContexts(DdContext.class);
5108                }
5109                public DdContext dd(int i) {
5110                        return getRuleContext(DdContext.class,i);
5111                }
5112                public List<DtContext> dt() {
5113                        return getRuleContexts(DtContext.class);
5114                }
5115                public DtContext dt(int i) {
5116                        return getRuleContext(DtContext.class,i);
5117                }
5118                public List<HeadContext> head() {
5119                        return getRuleContexts(HeadContext.class);
5120                }
5121                public HeadContext head(int i) {
5122                        return getRuleContext(HeadContext.class,i);
5123                }
5124                public List<HtmlContext> html() {
5125                        return getRuleContexts(HtmlContext.class);
5126                }
5127                public HtmlContext html(int i) {
5128                        return getRuleContext(HtmlContext.class,i);
5129                }
5130                public List<OptionContext> option() {
5131                        return getRuleContexts(OptionContext.class);
5132                }
5133                public OptionContext option(int i) {
5134                        return getRuleContext(OptionContext.class,i);
5135                }
5136                public List<TbodyContext> tbody() {
5137                        return getRuleContexts(TbodyContext.class);
5138                }
5139                public TbodyContext tbody(int i) {
5140                        return getRuleContext(TbodyContext.class,i);
5141                }
5142                public List<TheadContext> thead() {
5143                        return getRuleContexts(TheadContext.class);
5144                }
5145                public TheadContext thead(int i) {
5146                        return getRuleContext(TheadContext.class,i);
5147                }
5148                public List<TfootContext> tfoot() {
5149                        return getRuleContexts(TfootContext.class);
5150                }
5151                public TfootContext tfoot(int i) {
5152                        return getRuleContext(TfootContext.class,i);
5153                }
5154                public List<PTagOpenContext> pTagOpen() {
5155                        return getRuleContexts(PTagOpenContext.class);
5156                }
5157                public PTagOpenContext pTagOpen(int i) {
5158                        return getRuleContext(PTagOpenContext.class,i);
5159                }
5160                public List<LiTagOpenContext> liTagOpen() {
5161                        return getRuleContexts(LiTagOpenContext.class);
5162                }
5163                public LiTagOpenContext liTagOpen(int i) {
5164                        return getRuleContext(LiTagOpenContext.class,i);
5165                }
5166                public List<TrTagOpenContext> trTagOpen() {
5167                        return getRuleContexts(TrTagOpenContext.class);
5168                }
5169                public TrTagOpenContext trTagOpen(int i) {
5170                        return getRuleContext(TrTagOpenContext.class,i);
5171                }
5172                public List<TdTagOpenContext> tdTagOpen() {
5173                        return getRuleContexts(TdTagOpenContext.class);
5174                }
5175                public TdTagOpenContext tdTagOpen(int i) {
5176                        return getRuleContext(TdTagOpenContext.class,i);
5177                }
5178                public List<ThTagOpenContext> thTagOpen() {
5179                        return getRuleContexts(ThTagOpenContext.class);
5180                }
5181                public ThTagOpenContext thTagOpen(int i) {
5182                        return getRuleContext(ThTagOpenContext.class,i);
5183                }
5184                public List<ColgroupTagOpenContext> colgroupTagOpen() {
5185                        return getRuleContexts(ColgroupTagOpenContext.class);
5186                }
5187                public ColgroupTagOpenContext colgroupTagOpen(int i) {
5188                        return getRuleContext(ColgroupTagOpenContext.class,i);
5189                }
5190                public List<DdTagOpenContext> ddTagOpen() {
5191                        return getRuleContexts(DdTagOpenContext.class);
5192                }
5193                public DdTagOpenContext ddTagOpen(int i) {
5194                        return getRuleContext(DdTagOpenContext.class,i);
5195                }
5196                public List<DtTagOpenContext> dtTagOpen() {
5197                        return getRuleContexts(DtTagOpenContext.class);
5198                }
5199                public DtTagOpenContext dtTagOpen(int i) {
5200                        return getRuleContext(DtTagOpenContext.class,i);
5201                }
5202                public List<HeadTagOpenContext> headTagOpen() {
5203                        return getRuleContexts(HeadTagOpenContext.class);
5204                }
5205                public HeadTagOpenContext headTagOpen(int i) {
5206                        return getRuleContext(HeadTagOpenContext.class,i);
5207                }
5208                public List<HtmlTagOpenContext> htmlTagOpen() {
5209                        return getRuleContexts(HtmlTagOpenContext.class);
5210                }
5211                public HtmlTagOpenContext htmlTagOpen(int i) {
5212                        return getRuleContext(HtmlTagOpenContext.class,i);
5213                }
5214                public List<OptionTagOpenContext> optionTagOpen() {
5215                        return getRuleContexts(OptionTagOpenContext.class);
5216                }
5217                public OptionTagOpenContext optionTagOpen(int i) {
5218                        return getRuleContext(OptionTagOpenContext.class,i);
5219                }
5220                public List<TbodyTagOpenContext> tbodyTagOpen() {
5221                        return getRuleContexts(TbodyTagOpenContext.class);
5222                }
5223                public TbodyTagOpenContext tbodyTagOpen(int i) {
5224                        return getRuleContext(TbodyTagOpenContext.class,i);
5225                }
5226                public List<TheadTagOpenContext> theadTagOpen() {
5227                        return getRuleContexts(TheadTagOpenContext.class);
5228                }
5229                public TheadTagOpenContext theadTagOpen(int i) {
5230                        return getRuleContext(TheadTagOpenContext.class,i);
5231                }
5232                public List<TfootTagOpenContext> tfootTagOpen() {
5233                        return getRuleContexts(TfootTagOpenContext.class);
5234                }
5235                public TfootTagOpenContext tfootTagOpen(int i) {
5236                        return getRuleContext(TfootTagOpenContext.class,i);
5237                }
5238                public List<HtmlCommentContext> htmlComment() {
5239                        return getRuleContexts(HtmlCommentContext.class);
5240                }
5241                public HtmlCommentContext htmlComment(int i) {
5242                        return getRuleContext(HtmlCommentContext.class,i);
5243                }
5244                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5245                public TerminalNode CDATA(int i) {
5246                        return getToken(JavadocParser.CDATA, i);
5247                }
5248                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5249                public TerminalNode NEWLINE(int i) {
5250                        return getToken(JavadocParser.NEWLINE, i);
5251                }
5252                public List<TextContext> text() {
5253                        return getRuleContexts(TextContext.class);
5254                }
5255                public TextContext text(int i) {
5256                        return getRuleContext(TextContext.class,i);
5257                }
5258                public List<JavadocInlineTagContext> javadocInlineTag() {
5259                        return getRuleContexts(JavadocInlineTagContext.class);
5260                }
5261                public JavadocInlineTagContext javadocInlineTag(int i) {
5262                        return getRuleContext(JavadocInlineTagContext.class,i);
5263                }
5264                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5265                public TerminalNode LEADING_ASTERISK(int i) {
5266                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5267                }
5268                public BodyContext(ParserRuleContext parent, int invokingState) {
5269                        super(parent, invokingState);
5270                }
5271                @Override public int getRuleIndex() { return RULE_body; }
5272                @Override
5273                public void enterRule(ParseTreeListener listener) {
5274                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this);
5275                }
5276                @Override
5277                public void exitRule(ParseTreeListener listener) {
5278                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this);
5279                }
5280                @Override
5281                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5282                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this);
5283                        else return visitor.visitChildren(this);
5284                }
5285        }
5286
5287        public final BodyContext body() throws RecognitionException {
5288                BodyContext _localctx = new BodyContext(_ctx, getState());
5289                enterRule(_localctx, 46, RULE_body);
5290                try {
5291                        int _alt;
5292                        enterOuterAlt(_localctx, 1);
5293                        {
5294                        setState(675);
5295                        bodyTagOpen();
5296                        setState(715);
5297                        _errHandler.sync(this);
5298                        _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5299                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5300                                if ( _alt==1 ) {
5301                                        {
5302                                        setState(713);
5303                                        _errHandler.sync(this);
5304                                        switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
5305                                        case 1:
5306                                                {
5307                                                setState(676);
5308                                                htmlTag();
5309                                                }
5310                                                break;
5311                                        case 2:
5312                                                {
5313                                                setState(677);
5314                                                singletonTag();
5315                                                }
5316                                                break;
5317                                        case 3:
5318                                                {
5319                                                setState(678);
5320                                                paragraph();
5321                                                }
5322                                                break;
5323                                        case 4:
5324                                                {
5325                                                setState(679);
5326                                                li();
5327                                                }
5328                                                break;
5329                                        case 5:
5330                                                {
5331                                                setState(680);
5332                                                tr();
5333                                                }
5334                                                break;
5335                                        case 6:
5336                                                {
5337                                                setState(681);
5338                                                td();
5339                                                }
5340                                                break;
5341                                        case 7:
5342                                                {
5343                                                setState(682);
5344                                                th();
5345                                                }
5346                                                break;
5347                                        case 8:
5348                                                {
5349                                                setState(683);
5350                                                colgroup();
5351                                                }
5352                                                break;
5353                                        case 9:
5354                                                {
5355                                                setState(684);
5356                                                dd();
5357                                                }
5358                                                break;
5359                                        case 10:
5360                                                {
5361                                                setState(685);
5362                                                dt();
5363                                                }
5364                                                break;
5365                                        case 11:
5366                                                {
5367                                                setState(686);
5368                                                head();
5369                                                }
5370                                                break;
5371                                        case 12:
5372                                                {
5373                                                setState(687);
5374                                                html();
5375                                                }
5376                                                break;
5377                                        case 13:
5378                                                {
5379                                                setState(688);
5380                                                option();
5381                                                }
5382                                                break;
5383                                        case 14:
5384                                                {
5385                                                setState(689);
5386                                                tbody();
5387                                                }
5388                                                break;
5389                                        case 15:
5390                                                {
5391                                                setState(690);
5392                                                thead();
5393                                                }
5394                                                break;
5395                                        case 16:
5396                                                {
5397                                                setState(691);
5398                                                tfoot();
5399                                                }
5400                                                break;
5401                                        case 17:
5402                                                {
5403                                                setState(692);
5404                                                pTagOpen();
5405                                                }
5406                                                break;
5407                                        case 18:
5408                                                {
5409                                                setState(693);
5410                                                liTagOpen();
5411                                                }
5412                                                break;
5413                                        case 19:
5414                                                {
5415                                                setState(694);
5416                                                trTagOpen();
5417                                                }
5418                                                break;
5419                                        case 20:
5420                                                {
5421                                                setState(695);
5422                                                tdTagOpen();
5423                                                }
5424                                                break;
5425                                        case 21:
5426                                                {
5427                                                setState(696);
5428                                                thTagOpen();
5429                                                }
5430                                                break;
5431                                        case 22:
5432                                                {
5433                                                setState(697);
5434                                                colgroupTagOpen();
5435                                                }
5436                                                break;
5437                                        case 23:
5438                                                {
5439                                                setState(698);
5440                                                ddTagOpen();
5441                                                }
5442                                                break;
5443                                        case 24:
5444                                                {
5445                                                setState(699);
5446                                                dtTagOpen();
5447                                                }
5448                                                break;
5449                                        case 25:
5450                                                {
5451                                                setState(700);
5452                                                headTagOpen();
5453                                                }
5454                                                break;
5455                                        case 26:
5456                                                {
5457                                                setState(701);
5458                                                htmlTagOpen();
5459                                                }
5460                                                break;
5461                                        case 27:
5462                                                {
5463                                                setState(702);
5464                                                optionTagOpen();
5465                                                }
5466                                                break;
5467                                        case 28:
5468                                                {
5469                                                setState(703);
5470                                                tbodyTagOpen();
5471                                                }
5472                                                break;
5473                                        case 29:
5474                                                {
5475                                                setState(704);
5476                                                theadTagOpen();
5477                                                }
5478                                                break;
5479                                        case 30:
5480                                                {
5481                                                setState(705);
5482                                                tfootTagOpen();
5483                                                }
5484                                                break;
5485                                        case 31:
5486                                                {
5487                                                {
5488                                                setState(706);
5489                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5490                                                setState(707);
5491                                                match(LEADING_ASTERISK);
5492                                                }
5493                                                }
5494                                                break;
5495                                        case 32:
5496                                                {
5497                                                setState(708);
5498                                                htmlComment();
5499                                                }
5500                                                break;
5501                                        case 33:
5502                                                {
5503                                                setState(709);
5504                                                match(CDATA);
5505                                                }
5506                                                break;
5507                                        case 34:
5508                                                {
5509                                                setState(710);
5510                                                match(NEWLINE);
5511                                                }
5512                                                break;
5513                                        case 35:
5514                                                {
5515                                                setState(711);
5516                                                text();
5517                                                }
5518                                                break;
5519                                        case 36:
5520                                                {
5521                                                setState(712);
5522                                                javadocInlineTag();
5523                                                }
5524                                                break;
5525                                        }
5526                                        } 
5527                                }
5528                                setState(717);
5529                                _errHandler.sync(this);
5530                                _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5531                        }
5532                        setState(718);
5533                        bodyTagClose();
5534                        }
5535                }
5536                catch (RecognitionException re) {
5537                        _localctx.exception = re;
5538                        _errHandler.reportError(this, re);
5539                        _errHandler.recover(this, re);
5540                }
5541                finally {
5542                        exitRule();
5543                }
5544                return _localctx;
5545        }
5546
5547        public static class ColgroupTagOpenContext extends ParserRuleContext {
5548                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5549                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5550                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5551                public List<AttributeContext> attribute() {
5552                        return getRuleContexts(AttributeContext.class);
5553                }
5554                public AttributeContext attribute(int i) {
5555                        return getRuleContext(AttributeContext.class,i);
5556                }
5557                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5558                public TerminalNode NEWLINE(int i) {
5559                        return getToken(JavadocParser.NEWLINE, i);
5560                }
5561                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5562                public TerminalNode LEADING_ASTERISK(int i) {
5563                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5564                }
5565                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5566                public TerminalNode WS(int i) {
5567                        return getToken(JavadocParser.WS, i);
5568                }
5569                public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) {
5570                        super(parent, invokingState);
5571                }
5572                @Override public int getRuleIndex() { return RULE_colgroupTagOpen; }
5573                @Override
5574                public void enterRule(ParseTreeListener listener) {
5575                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this);
5576                }
5577                @Override
5578                public void exitRule(ParseTreeListener listener) {
5579                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this);
5580                }
5581                @Override
5582                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5583                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this);
5584                        else return visitor.visitChildren(this);
5585                }
5586        }
5587
5588        public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException {
5589                ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState());
5590                enterRule(_localctx, 48, RULE_colgroupTagOpen);
5591                int _la;
5592                try {
5593                        enterOuterAlt(_localctx, 1);
5594                        {
5595                        setState(720);
5596                        match(OPEN);
5597                        setState(721);
5598                        match(COLGROUP_HTML_TAG_NAME);
5599                        setState(728);
5600                        _errHandler.sync(this);
5601                        _la = _input.LA(1);
5602                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5603                                {
5604                                setState(726);
5605                                switch (_input.LA(1)) {
5606                                case HTML_TAG_NAME:
5607                                        {
5608                                        setState(722);
5609                                        attribute();
5610                                        }
5611                                        break;
5612                                case NEWLINE:
5613                                        {
5614                                        setState(723);
5615                                        match(NEWLINE);
5616                                        }
5617                                        break;
5618                                case LEADING_ASTERISK:
5619                                        {
5620                                        setState(724);
5621                                        match(LEADING_ASTERISK);
5622                                        }
5623                                        break;
5624                                case WS:
5625                                        {
5626                                        setState(725);
5627                                        match(WS);
5628                                        }
5629                                        break;
5630                                default:
5631                                        throw new NoViableAltException(this);
5632                                }
5633                                }
5634                                setState(730);
5635                                _errHandler.sync(this);
5636                                _la = _input.LA(1);
5637                        }
5638                        setState(731);
5639                        match(CLOSE);
5640                        }
5641                }
5642                catch (RecognitionException re) {
5643                        _localctx.exception = re;
5644                        _errHandler.reportError(this, re);
5645                        _errHandler.recover(this, re);
5646                }
5647                finally {
5648                        exitRule();
5649                }
5650                return _localctx;
5651        }
5652
5653        public static class ColgroupTagCloseContext extends ParserRuleContext {
5654                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5655                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5656                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5657                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5658                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5659                public TerminalNode NEWLINE(int i) {
5660                        return getToken(JavadocParser.NEWLINE, i);
5661                }
5662                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5663                public TerminalNode LEADING_ASTERISK(int i) {
5664                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5665                }
5666                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5667                public TerminalNode WS(int i) {
5668                        return getToken(JavadocParser.WS, i);
5669                }
5670                public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) {
5671                        super(parent, invokingState);
5672                }
5673                @Override public int getRuleIndex() { return RULE_colgroupTagClose; }
5674                @Override
5675                public void enterRule(ParseTreeListener listener) {
5676                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this);
5677                }
5678                @Override
5679                public void exitRule(ParseTreeListener listener) {
5680                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this);
5681                }
5682                @Override
5683                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5684                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this);
5685                        else return visitor.visitChildren(this);
5686                }
5687        }
5688
5689        public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException {
5690                ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState());
5691                enterRule(_localctx, 50, RULE_colgroupTagClose);
5692                int _la;
5693                try {
5694                        enterOuterAlt(_localctx, 1);
5695                        {
5696                        setState(733);
5697                        match(OPEN);
5698                        setState(734);
5699                        match(SLASH);
5700                        setState(735);
5701                        match(COLGROUP_HTML_TAG_NAME);
5702                        setState(739);
5703                        _errHandler.sync(this);
5704                        _la = _input.LA(1);
5705                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5706                                {
5707                                {
5708                                setState(736);
5709                                _la = _input.LA(1);
5710                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5711                                _errHandler.recoverInline(this);
5712                                } else {
5713                                        consume();
5714                                }
5715                                }
5716                                }
5717                                setState(741);
5718                                _errHandler.sync(this);
5719                                _la = _input.LA(1);
5720                        }
5721                        setState(742);
5722                        match(CLOSE);
5723                        }
5724                }
5725                catch (RecognitionException re) {
5726                        _localctx.exception = re;
5727                        _errHandler.reportError(this, re);
5728                        _errHandler.recover(this, re);
5729                }
5730                finally {
5731                        exitRule();
5732                }
5733                return _localctx;
5734        }
5735
5736        public static class ColgroupContext extends ParserRuleContext {
5737                public ColgroupTagOpenContext colgroupTagOpen() {
5738                        return getRuleContext(ColgroupTagOpenContext.class,0);
5739                }
5740                public ColgroupTagCloseContext colgroupTagClose() {
5741                        return getRuleContext(ColgroupTagCloseContext.class,0);
5742                }
5743                public List<HtmlTagContext> htmlTag() {
5744                        return getRuleContexts(HtmlTagContext.class);
5745                }
5746                public HtmlTagContext htmlTag(int i) {
5747                        return getRuleContext(HtmlTagContext.class,i);
5748                }
5749                public List<SingletonTagContext> singletonTag() {
5750                        return getRuleContexts(SingletonTagContext.class);
5751                }
5752                public SingletonTagContext singletonTag(int i) {
5753                        return getRuleContext(SingletonTagContext.class,i);
5754                }
5755                public List<ParagraphContext> paragraph() {
5756                        return getRuleContexts(ParagraphContext.class);
5757                }
5758                public ParagraphContext paragraph(int i) {
5759                        return getRuleContext(ParagraphContext.class,i);
5760                }
5761                public List<LiContext> li() {
5762                        return getRuleContexts(LiContext.class);
5763                }
5764                public LiContext li(int i) {
5765                        return getRuleContext(LiContext.class,i);
5766                }
5767                public List<TrContext> tr() {
5768                        return getRuleContexts(TrContext.class);
5769                }
5770                public TrContext tr(int i) {
5771                        return getRuleContext(TrContext.class,i);
5772                }
5773                public List<TdContext> td() {
5774                        return getRuleContexts(TdContext.class);
5775                }
5776                public TdContext td(int i) {
5777                        return getRuleContext(TdContext.class,i);
5778                }
5779                public List<ThContext> th() {
5780                        return getRuleContexts(ThContext.class);
5781                }
5782                public ThContext th(int i) {
5783                        return getRuleContext(ThContext.class,i);
5784                }
5785                public List<BodyContext> body() {
5786                        return getRuleContexts(BodyContext.class);
5787                }
5788                public BodyContext body(int i) {
5789                        return getRuleContext(BodyContext.class,i);
5790                }
5791                public List<DdContext> dd() {
5792                        return getRuleContexts(DdContext.class);
5793                }
5794                public DdContext dd(int i) {
5795                        return getRuleContext(DdContext.class,i);
5796                }
5797                public List<DtContext> dt() {
5798                        return getRuleContexts(DtContext.class);
5799                }
5800                public DtContext dt(int i) {
5801                        return getRuleContext(DtContext.class,i);
5802                }
5803                public List<HeadContext> head() {
5804                        return getRuleContexts(HeadContext.class);
5805                }
5806                public HeadContext head(int i) {
5807                        return getRuleContext(HeadContext.class,i);
5808                }
5809                public List<HtmlContext> html() {
5810                        return getRuleContexts(HtmlContext.class);
5811                }
5812                public HtmlContext html(int i) {
5813                        return getRuleContext(HtmlContext.class,i);
5814                }
5815                public List<OptionContext> option() {
5816                        return getRuleContexts(OptionContext.class);
5817                }
5818                public OptionContext option(int i) {
5819                        return getRuleContext(OptionContext.class,i);
5820                }
5821                public List<TbodyContext> tbody() {
5822                        return getRuleContexts(TbodyContext.class);
5823                }
5824                public TbodyContext tbody(int i) {
5825                        return getRuleContext(TbodyContext.class,i);
5826                }
5827                public List<TheadContext> thead() {
5828                        return getRuleContexts(TheadContext.class);
5829                }
5830                public TheadContext thead(int i) {
5831                        return getRuleContext(TheadContext.class,i);
5832                }
5833                public List<TfootContext> tfoot() {
5834                        return getRuleContexts(TfootContext.class);
5835                }
5836                public TfootContext tfoot(int i) {
5837                        return getRuleContext(TfootContext.class,i);
5838                }
5839                public List<PTagOpenContext> pTagOpen() {
5840                        return getRuleContexts(PTagOpenContext.class);
5841                }
5842                public PTagOpenContext pTagOpen(int i) {
5843                        return getRuleContext(PTagOpenContext.class,i);
5844                }
5845                public List<LiTagOpenContext> liTagOpen() {
5846                        return getRuleContexts(LiTagOpenContext.class);
5847                }
5848                public LiTagOpenContext liTagOpen(int i) {
5849                        return getRuleContext(LiTagOpenContext.class,i);
5850                }
5851                public List<TrTagOpenContext> trTagOpen() {
5852                        return getRuleContexts(TrTagOpenContext.class);
5853                }
5854                public TrTagOpenContext trTagOpen(int i) {
5855                        return getRuleContext(TrTagOpenContext.class,i);
5856                }
5857                public List<TdTagOpenContext> tdTagOpen() {
5858                        return getRuleContexts(TdTagOpenContext.class);
5859                }
5860                public TdTagOpenContext tdTagOpen(int i) {
5861                        return getRuleContext(TdTagOpenContext.class,i);
5862                }
5863                public List<ThTagOpenContext> thTagOpen() {
5864                        return getRuleContexts(ThTagOpenContext.class);
5865                }
5866                public ThTagOpenContext thTagOpen(int i) {
5867                        return getRuleContext(ThTagOpenContext.class,i);
5868                }
5869                public List<BodyTagOpenContext> bodyTagOpen() {
5870                        return getRuleContexts(BodyTagOpenContext.class);
5871                }
5872                public BodyTagOpenContext bodyTagOpen(int i) {
5873                        return getRuleContext(BodyTagOpenContext.class,i);
5874                }
5875                public List<DdTagOpenContext> ddTagOpen() {
5876                        return getRuleContexts(DdTagOpenContext.class);
5877                }
5878                public DdTagOpenContext ddTagOpen(int i) {
5879                        return getRuleContext(DdTagOpenContext.class,i);
5880                }
5881                public List<DtTagOpenContext> dtTagOpen() {
5882                        return getRuleContexts(DtTagOpenContext.class);
5883                }
5884                public DtTagOpenContext dtTagOpen(int i) {
5885                        return getRuleContext(DtTagOpenContext.class,i);
5886                }
5887                public List<HeadTagOpenContext> headTagOpen() {
5888                        return getRuleContexts(HeadTagOpenContext.class);
5889                }
5890                public HeadTagOpenContext headTagOpen(int i) {
5891                        return getRuleContext(HeadTagOpenContext.class,i);
5892                }
5893                public List<HtmlTagOpenContext> htmlTagOpen() {
5894                        return getRuleContexts(HtmlTagOpenContext.class);
5895                }
5896                public HtmlTagOpenContext htmlTagOpen(int i) {
5897                        return getRuleContext(HtmlTagOpenContext.class,i);
5898                }
5899                public List<OptionTagOpenContext> optionTagOpen() {
5900                        return getRuleContexts(OptionTagOpenContext.class);
5901                }
5902                public OptionTagOpenContext optionTagOpen(int i) {
5903                        return getRuleContext(OptionTagOpenContext.class,i);
5904                }
5905                public List<TbodyTagOpenContext> tbodyTagOpen() {
5906                        return getRuleContexts(TbodyTagOpenContext.class);
5907                }
5908                public TbodyTagOpenContext tbodyTagOpen(int i) {
5909                        return getRuleContext(TbodyTagOpenContext.class,i);
5910                }
5911                public List<TheadTagOpenContext> theadTagOpen() {
5912                        return getRuleContexts(TheadTagOpenContext.class);
5913                }
5914                public TheadTagOpenContext theadTagOpen(int i) {
5915                        return getRuleContext(TheadTagOpenContext.class,i);
5916                }
5917                public List<TfootTagOpenContext> tfootTagOpen() {
5918                        return getRuleContexts(TfootTagOpenContext.class);
5919                }
5920                public TfootTagOpenContext tfootTagOpen(int i) {
5921                        return getRuleContext(TfootTagOpenContext.class,i);
5922                }
5923                public List<HtmlCommentContext> htmlComment() {
5924                        return getRuleContexts(HtmlCommentContext.class);
5925                }
5926                public HtmlCommentContext htmlComment(int i) {
5927                        return getRuleContext(HtmlCommentContext.class,i);
5928                }
5929                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5930                public TerminalNode CDATA(int i) {
5931                        return getToken(JavadocParser.CDATA, i);
5932                }
5933                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5934                public TerminalNode NEWLINE(int i) {
5935                        return getToken(JavadocParser.NEWLINE, i);
5936                }
5937                public List<TextContext> text() {
5938                        return getRuleContexts(TextContext.class);
5939                }
5940                public TextContext text(int i) {
5941                        return getRuleContext(TextContext.class,i);
5942                }
5943                public List<JavadocInlineTagContext> javadocInlineTag() {
5944                        return getRuleContexts(JavadocInlineTagContext.class);
5945                }
5946                public JavadocInlineTagContext javadocInlineTag(int i) {
5947                        return getRuleContext(JavadocInlineTagContext.class,i);
5948                }
5949                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5950                public TerminalNode LEADING_ASTERISK(int i) {
5951                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5952                }
5953                public ColgroupContext(ParserRuleContext parent, int invokingState) {
5954                        super(parent, invokingState);
5955                }
5956                @Override public int getRuleIndex() { return RULE_colgroup; }
5957                @Override
5958                public void enterRule(ParseTreeListener listener) {
5959                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this);
5960                }
5961                @Override
5962                public void exitRule(ParseTreeListener listener) {
5963                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this);
5964                }
5965                @Override
5966                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5967                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this);
5968                        else return visitor.visitChildren(this);
5969                }
5970        }
5971
5972        public final ColgroupContext colgroup() throws RecognitionException {
5973                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
5974                enterRule(_localctx, 52, RULE_colgroup);
5975                try {
5976                        int _alt;
5977                        enterOuterAlt(_localctx, 1);
5978                        {
5979                        setState(744);
5980                        colgroupTagOpen();
5981                        setState(784);
5982                        _errHandler.sync(this);
5983                        _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
5984                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5985                                if ( _alt==1 ) {
5986                                        {
5987                                        setState(782);
5988                                        _errHandler.sync(this);
5989                                        switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
5990                                        case 1:
5991                                                {
5992                                                setState(745);
5993                                                htmlTag();
5994                                                }
5995                                                break;
5996                                        case 2:
5997                                                {
5998                                                setState(746);
5999                                                singletonTag();
6000                                                }
6001                                                break;
6002                                        case 3:
6003                                                {
6004                                                setState(747);
6005                                                paragraph();
6006                                                }
6007                                                break;
6008                                        case 4:
6009                                                {
6010                                                setState(748);
6011                                                li();
6012                                                }
6013                                                break;
6014                                        case 5:
6015                                                {
6016                                                setState(749);
6017                                                tr();
6018                                                }
6019                                                break;
6020                                        case 6:
6021                                                {
6022                                                setState(750);
6023                                                td();
6024                                                }
6025                                                break;
6026                                        case 7:
6027                                                {
6028                                                setState(751);
6029                                                th();
6030                                                }
6031                                                break;
6032                                        case 8:
6033                                                {
6034                                                setState(752);
6035                                                body();
6036                                                }
6037                                                break;
6038                                        case 9:
6039                                                {
6040                                                setState(753);
6041                                                dd();
6042                                                }
6043                                                break;
6044                                        case 10:
6045                                                {
6046                                                setState(754);
6047                                                dt();
6048                                                }
6049                                                break;
6050                                        case 11:
6051                                                {
6052                                                setState(755);
6053                                                head();
6054                                                }
6055                                                break;
6056                                        case 12:
6057                                                {
6058                                                setState(756);
6059                                                html();
6060                                                }
6061                                                break;
6062                                        case 13:
6063                                                {
6064                                                setState(757);
6065                                                option();
6066                                                }
6067                                                break;
6068                                        case 14:
6069                                                {
6070                                                setState(758);
6071                                                tbody();
6072                                                }
6073                                                break;
6074                                        case 15:
6075                                                {
6076                                                setState(759);
6077                                                thead();
6078                                                }
6079                                                break;
6080                                        case 16:
6081                                                {
6082                                                setState(760);
6083                                                tfoot();
6084                                                }
6085                                                break;
6086                                        case 17:
6087                                                {
6088                                                setState(761);
6089                                                pTagOpen();
6090                                                }
6091                                                break;
6092                                        case 18:
6093                                                {
6094                                                setState(762);
6095                                                liTagOpen();
6096                                                }
6097                                                break;
6098                                        case 19:
6099                                                {
6100                                                setState(763);
6101                                                trTagOpen();
6102                                                }
6103                                                break;
6104                                        case 20:
6105                                                {
6106                                                setState(764);
6107                                                tdTagOpen();
6108                                                }
6109                                                break;
6110                                        case 21:
6111                                                {
6112                                                setState(765);
6113                                                thTagOpen();
6114                                                }
6115                                                break;
6116                                        case 22:
6117                                                {
6118                                                setState(766);
6119                                                bodyTagOpen();
6120                                                }
6121                                                break;
6122                                        case 23:
6123                                                {
6124                                                setState(767);
6125                                                ddTagOpen();
6126                                                }
6127                                                break;
6128                                        case 24:
6129                                                {
6130                                                setState(768);
6131                                                dtTagOpen();
6132                                                }
6133                                                break;
6134                                        case 25:
6135                                                {
6136                                                setState(769);
6137                                                headTagOpen();
6138                                                }
6139                                                break;
6140                                        case 26:
6141                                                {
6142                                                setState(770);
6143                                                htmlTagOpen();
6144                                                }
6145                                                break;
6146                                        case 27:
6147                                                {
6148                                                setState(771);
6149                                                optionTagOpen();
6150                                                }
6151                                                break;
6152                                        case 28:
6153                                                {
6154                                                setState(772);
6155                                                tbodyTagOpen();
6156                                                }
6157                                                break;
6158                                        case 29:
6159                                                {
6160                                                setState(773);
6161                                                theadTagOpen();
6162                                                }
6163                                                break;
6164                                        case 30:
6165                                                {
6166                                                setState(774);
6167                                                tfootTagOpen();
6168                                                }
6169                                                break;
6170                                        case 31:
6171                                                {
6172                                                {
6173                                                setState(775);
6174                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6175                                                setState(776);
6176                                                match(LEADING_ASTERISK);
6177                                                }
6178                                                }
6179                                                break;
6180                                        case 32:
6181                                                {
6182                                                setState(777);
6183                                                htmlComment();
6184                                                }
6185                                                break;
6186                                        case 33:
6187                                                {
6188                                                setState(778);
6189                                                match(CDATA);
6190                                                }
6191                                                break;
6192                                        case 34:
6193                                                {
6194                                                setState(779);
6195                                                match(NEWLINE);
6196                                                }
6197                                                break;
6198                                        case 35:
6199                                                {
6200                                                setState(780);
6201                                                text();
6202                                                }
6203                                                break;
6204                                        case 36:
6205                                                {
6206                                                setState(781);
6207                                                javadocInlineTag();
6208                                                }
6209                                                break;
6210                                        }
6211                                        } 
6212                                }
6213                                setState(786);
6214                                _errHandler.sync(this);
6215                                _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6216                        }
6217                        setState(787);
6218                        colgroupTagClose();
6219                        }
6220                }
6221                catch (RecognitionException re) {
6222                        _localctx.exception = re;
6223                        _errHandler.reportError(this, re);
6224                        _errHandler.recover(this, re);
6225                }
6226                finally {
6227                        exitRule();
6228                }
6229                return _localctx;
6230        }
6231
6232        public static class DdTagOpenContext extends ParserRuleContext {
6233                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6234                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6235                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6236                public List<AttributeContext> attribute() {
6237                        return getRuleContexts(AttributeContext.class);
6238                }
6239                public AttributeContext attribute(int i) {
6240                        return getRuleContext(AttributeContext.class,i);
6241                }
6242                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6243                public TerminalNode NEWLINE(int i) {
6244                        return getToken(JavadocParser.NEWLINE, i);
6245                }
6246                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6247                public TerminalNode LEADING_ASTERISK(int i) {
6248                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6249                }
6250                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6251                public TerminalNode WS(int i) {
6252                        return getToken(JavadocParser.WS, i);
6253                }
6254                public DdTagOpenContext(ParserRuleContext parent, int invokingState) {
6255                        super(parent, invokingState);
6256                }
6257                @Override public int getRuleIndex() { return RULE_ddTagOpen; }
6258                @Override
6259                public void enterRule(ParseTreeListener listener) {
6260                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this);
6261                }
6262                @Override
6263                public void exitRule(ParseTreeListener listener) {
6264                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this);
6265                }
6266                @Override
6267                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6268                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this);
6269                        else return visitor.visitChildren(this);
6270                }
6271        }
6272
6273        public final DdTagOpenContext ddTagOpen() throws RecognitionException {
6274                DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState());
6275                enterRule(_localctx, 54, RULE_ddTagOpen);
6276                int _la;
6277                try {
6278                        enterOuterAlt(_localctx, 1);
6279                        {
6280                        setState(789);
6281                        match(OPEN);
6282                        setState(790);
6283                        match(DD_HTML_TAG_NAME);
6284                        setState(797);
6285                        _errHandler.sync(this);
6286                        _la = _input.LA(1);
6287                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6288                                {
6289                                setState(795);
6290                                switch (_input.LA(1)) {
6291                                case HTML_TAG_NAME:
6292                                        {
6293                                        setState(791);
6294                                        attribute();
6295                                        }
6296                                        break;
6297                                case NEWLINE:
6298                                        {
6299                                        setState(792);
6300                                        match(NEWLINE);
6301                                        }
6302                                        break;
6303                                case LEADING_ASTERISK:
6304                                        {
6305                                        setState(793);
6306                                        match(LEADING_ASTERISK);
6307                                        }
6308                                        break;
6309                                case WS:
6310                                        {
6311                                        setState(794);
6312                                        match(WS);
6313                                        }
6314                                        break;
6315                                default:
6316                                        throw new NoViableAltException(this);
6317                                }
6318                                }
6319                                setState(799);
6320                                _errHandler.sync(this);
6321                                _la = _input.LA(1);
6322                        }
6323                        setState(800);
6324                        match(CLOSE);
6325                        }
6326                }
6327                catch (RecognitionException re) {
6328                        _localctx.exception = re;
6329                        _errHandler.reportError(this, re);
6330                        _errHandler.recover(this, re);
6331                }
6332                finally {
6333                        exitRule();
6334                }
6335                return _localctx;
6336        }
6337
6338        public static class DdTagCloseContext extends ParserRuleContext {
6339                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6340                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6341                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6342                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6343                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6344                public TerminalNode NEWLINE(int i) {
6345                        return getToken(JavadocParser.NEWLINE, i);
6346                }
6347                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6348                public TerminalNode LEADING_ASTERISK(int i) {
6349                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6350                }
6351                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6352                public TerminalNode WS(int i) {
6353                        return getToken(JavadocParser.WS, i);
6354                }
6355                public DdTagCloseContext(ParserRuleContext parent, int invokingState) {
6356                        super(parent, invokingState);
6357                }
6358                @Override public int getRuleIndex() { return RULE_ddTagClose; }
6359                @Override
6360                public void enterRule(ParseTreeListener listener) {
6361                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this);
6362                }
6363                @Override
6364                public void exitRule(ParseTreeListener listener) {
6365                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this);
6366                }
6367                @Override
6368                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6369                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this);
6370                        else return visitor.visitChildren(this);
6371                }
6372        }
6373
6374        public final DdTagCloseContext ddTagClose() throws RecognitionException {
6375                DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState());
6376                enterRule(_localctx, 56, RULE_ddTagClose);
6377                int _la;
6378                try {
6379                        enterOuterAlt(_localctx, 1);
6380                        {
6381                        setState(802);
6382                        match(OPEN);
6383                        setState(803);
6384                        match(SLASH);
6385                        setState(804);
6386                        match(DD_HTML_TAG_NAME);
6387                        setState(808);
6388                        _errHandler.sync(this);
6389                        _la = _input.LA(1);
6390                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6391                                {
6392                                {
6393                                setState(805);
6394                                _la = _input.LA(1);
6395                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6396                                _errHandler.recoverInline(this);
6397                                } else {
6398                                        consume();
6399                                }
6400                                }
6401                                }
6402                                setState(810);
6403                                _errHandler.sync(this);
6404                                _la = _input.LA(1);
6405                        }
6406                        setState(811);
6407                        match(CLOSE);
6408                        }
6409                }
6410                catch (RecognitionException re) {
6411                        _localctx.exception = re;
6412                        _errHandler.reportError(this, re);
6413                        _errHandler.recover(this, re);
6414                }
6415                finally {
6416                        exitRule();
6417                }
6418                return _localctx;
6419        }
6420
6421        public static class DdContext extends ParserRuleContext {
6422                public DdTagOpenContext ddTagOpen() {
6423                        return getRuleContext(DdTagOpenContext.class,0);
6424                }
6425                public DdTagCloseContext ddTagClose() {
6426                        return getRuleContext(DdTagCloseContext.class,0);
6427                }
6428                public List<HtmlTagContext> htmlTag() {
6429                        return getRuleContexts(HtmlTagContext.class);
6430                }
6431                public HtmlTagContext htmlTag(int i) {
6432                        return getRuleContext(HtmlTagContext.class,i);
6433                }
6434                public List<SingletonTagContext> singletonTag() {
6435                        return getRuleContexts(SingletonTagContext.class);
6436                }
6437                public SingletonTagContext singletonTag(int i) {
6438                        return getRuleContext(SingletonTagContext.class,i);
6439                }
6440                public List<ParagraphContext> paragraph() {
6441                        return getRuleContexts(ParagraphContext.class);
6442                }
6443                public ParagraphContext paragraph(int i) {
6444                        return getRuleContext(ParagraphContext.class,i);
6445                }
6446                public List<LiContext> li() {
6447                        return getRuleContexts(LiContext.class);
6448                }
6449                public LiContext li(int i) {
6450                        return getRuleContext(LiContext.class,i);
6451                }
6452                public List<TrContext> tr() {
6453                        return getRuleContexts(TrContext.class);
6454                }
6455                public TrContext tr(int i) {
6456                        return getRuleContext(TrContext.class,i);
6457                }
6458                public List<TdContext> td() {
6459                        return getRuleContexts(TdContext.class);
6460                }
6461                public TdContext td(int i) {
6462                        return getRuleContext(TdContext.class,i);
6463                }
6464                public List<ThContext> th() {
6465                        return getRuleContexts(ThContext.class);
6466                }
6467                public ThContext th(int i) {
6468                        return getRuleContext(ThContext.class,i);
6469                }
6470                public List<BodyContext> body() {
6471                        return getRuleContexts(BodyContext.class);
6472                }
6473                public BodyContext body(int i) {
6474                        return getRuleContext(BodyContext.class,i);
6475                }
6476                public List<ColgroupContext> colgroup() {
6477                        return getRuleContexts(ColgroupContext.class);
6478                }
6479                public ColgroupContext colgroup(int i) {
6480                        return getRuleContext(ColgroupContext.class,i);
6481                }
6482                public List<DtContext> dt() {
6483                        return getRuleContexts(DtContext.class);
6484                }
6485                public DtContext dt(int i) {
6486                        return getRuleContext(DtContext.class,i);
6487                }
6488                public List<HeadContext> head() {
6489                        return getRuleContexts(HeadContext.class);
6490                }
6491                public HeadContext head(int i) {
6492                        return getRuleContext(HeadContext.class,i);
6493                }
6494                public List<HtmlContext> html() {
6495                        return getRuleContexts(HtmlContext.class);
6496                }
6497                public HtmlContext html(int i) {
6498                        return getRuleContext(HtmlContext.class,i);
6499                }
6500                public List<OptionContext> option() {
6501                        return getRuleContexts(OptionContext.class);
6502                }
6503                public OptionContext option(int i) {
6504                        return getRuleContext(OptionContext.class,i);
6505                }
6506                public List<TbodyContext> tbody() {
6507                        return getRuleContexts(TbodyContext.class);
6508                }
6509                public TbodyContext tbody(int i) {
6510                        return getRuleContext(TbodyContext.class,i);
6511                }
6512                public List<TheadContext> thead() {
6513                        return getRuleContexts(TheadContext.class);
6514                }
6515                public TheadContext thead(int i) {
6516                        return getRuleContext(TheadContext.class,i);
6517                }
6518                public List<TfootContext> tfoot() {
6519                        return getRuleContexts(TfootContext.class);
6520                }
6521                public TfootContext tfoot(int i) {
6522                        return getRuleContext(TfootContext.class,i);
6523                }
6524                public List<PTagOpenContext> pTagOpen() {
6525                        return getRuleContexts(PTagOpenContext.class);
6526                }
6527                public PTagOpenContext pTagOpen(int i) {
6528                        return getRuleContext(PTagOpenContext.class,i);
6529                }
6530                public List<LiTagOpenContext> liTagOpen() {
6531                        return getRuleContexts(LiTagOpenContext.class);
6532                }
6533                public LiTagOpenContext liTagOpen(int i) {
6534                        return getRuleContext(LiTagOpenContext.class,i);
6535                }
6536                public List<TrTagOpenContext> trTagOpen() {
6537                        return getRuleContexts(TrTagOpenContext.class);
6538                }
6539                public TrTagOpenContext trTagOpen(int i) {
6540                        return getRuleContext(TrTagOpenContext.class,i);
6541                }
6542                public List<TdTagOpenContext> tdTagOpen() {
6543                        return getRuleContexts(TdTagOpenContext.class);
6544                }
6545                public TdTagOpenContext tdTagOpen(int i) {
6546                        return getRuleContext(TdTagOpenContext.class,i);
6547                }
6548                public List<ThTagOpenContext> thTagOpen() {
6549                        return getRuleContexts(ThTagOpenContext.class);
6550                }
6551                public ThTagOpenContext thTagOpen(int i) {
6552                        return getRuleContext(ThTagOpenContext.class,i);
6553                }
6554                public List<BodyTagOpenContext> bodyTagOpen() {
6555                        return getRuleContexts(BodyTagOpenContext.class);
6556                }
6557                public BodyTagOpenContext bodyTagOpen(int i) {
6558                        return getRuleContext(BodyTagOpenContext.class,i);
6559                }
6560                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6561                        return getRuleContexts(ColgroupTagOpenContext.class);
6562                }
6563                public ColgroupTagOpenContext colgroupTagOpen(int i) {
6564                        return getRuleContext(ColgroupTagOpenContext.class,i);
6565                }
6566                public List<DtTagOpenContext> dtTagOpen() {
6567                        return getRuleContexts(DtTagOpenContext.class);
6568                }
6569                public DtTagOpenContext dtTagOpen(int i) {
6570                        return getRuleContext(DtTagOpenContext.class,i);
6571                }
6572                public List<HeadTagOpenContext> headTagOpen() {
6573                        return getRuleContexts(HeadTagOpenContext.class);
6574                }
6575                public HeadTagOpenContext headTagOpen(int i) {
6576                        return getRuleContext(HeadTagOpenContext.class,i);
6577                }
6578                public List<HtmlTagOpenContext> htmlTagOpen() {
6579                        return getRuleContexts(HtmlTagOpenContext.class);
6580                }
6581                public HtmlTagOpenContext htmlTagOpen(int i) {
6582                        return getRuleContext(HtmlTagOpenContext.class,i);
6583                }
6584                public List<OptionTagOpenContext> optionTagOpen() {
6585                        return getRuleContexts(OptionTagOpenContext.class);
6586                }
6587                public OptionTagOpenContext optionTagOpen(int i) {
6588                        return getRuleContext(OptionTagOpenContext.class,i);
6589                }
6590                public List<TbodyTagOpenContext> tbodyTagOpen() {
6591                        return getRuleContexts(TbodyTagOpenContext.class);
6592                }
6593                public TbodyTagOpenContext tbodyTagOpen(int i) {
6594                        return getRuleContext(TbodyTagOpenContext.class,i);
6595                }
6596                public List<TheadTagOpenContext> theadTagOpen() {
6597                        return getRuleContexts(TheadTagOpenContext.class);
6598                }
6599                public TheadTagOpenContext theadTagOpen(int i) {
6600                        return getRuleContext(TheadTagOpenContext.class,i);
6601                }
6602                public List<TfootTagOpenContext> tfootTagOpen() {
6603                        return getRuleContexts(TfootTagOpenContext.class);
6604                }
6605                public TfootTagOpenContext tfootTagOpen(int i) {
6606                        return getRuleContext(TfootTagOpenContext.class,i);
6607                }
6608                public List<HtmlCommentContext> htmlComment() {
6609                        return getRuleContexts(HtmlCommentContext.class);
6610                }
6611                public HtmlCommentContext htmlComment(int i) {
6612                        return getRuleContext(HtmlCommentContext.class,i);
6613                }
6614                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6615                public TerminalNode CDATA(int i) {
6616                        return getToken(JavadocParser.CDATA, i);
6617                }
6618                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6619                public TerminalNode NEWLINE(int i) {
6620                        return getToken(JavadocParser.NEWLINE, i);
6621                }
6622                public List<TextContext> text() {
6623                        return getRuleContexts(TextContext.class);
6624                }
6625                public TextContext text(int i) {
6626                        return getRuleContext(TextContext.class,i);
6627                }
6628                public List<JavadocInlineTagContext> javadocInlineTag() {
6629                        return getRuleContexts(JavadocInlineTagContext.class);
6630                }
6631                public JavadocInlineTagContext javadocInlineTag(int i) {
6632                        return getRuleContext(JavadocInlineTagContext.class,i);
6633                }
6634                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6635                public TerminalNode LEADING_ASTERISK(int i) {
6636                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6637                }
6638                public DdContext(ParserRuleContext parent, int invokingState) {
6639                        super(parent, invokingState);
6640                }
6641                @Override public int getRuleIndex() { return RULE_dd; }
6642                @Override
6643                public void enterRule(ParseTreeListener listener) {
6644                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this);
6645                }
6646                @Override
6647                public void exitRule(ParseTreeListener listener) {
6648                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this);
6649                }
6650                @Override
6651                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6652                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this);
6653                        else return visitor.visitChildren(this);
6654                }
6655        }
6656
6657        public final DdContext dd() throws RecognitionException {
6658                DdContext _localctx = new DdContext(_ctx, getState());
6659                enterRule(_localctx, 58, RULE_dd);
6660                try {
6661                        int _alt;
6662                        enterOuterAlt(_localctx, 1);
6663                        {
6664                        setState(813);
6665                        ddTagOpen();
6666                        setState(853);
6667                        _errHandler.sync(this);
6668                        _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6669                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6670                                if ( _alt==1 ) {
6671                                        {
6672                                        setState(851);
6673                                        _errHandler.sync(this);
6674                                        switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
6675                                        case 1:
6676                                                {
6677                                                setState(814);
6678                                                htmlTag();
6679                                                }
6680                                                break;
6681                                        case 2:
6682                                                {
6683                                                setState(815);
6684                                                singletonTag();
6685                                                }
6686                                                break;
6687                                        case 3:
6688                                                {
6689                                                setState(816);
6690                                                paragraph();
6691                                                }
6692                                                break;
6693                                        case 4:
6694                                                {
6695                                                setState(817);
6696                                                li();
6697                                                }
6698                                                break;
6699                                        case 5:
6700                                                {
6701                                                setState(818);
6702                                                tr();
6703                                                }
6704                                                break;
6705                                        case 6:
6706                                                {
6707                                                setState(819);
6708                                                td();
6709                                                }
6710                                                break;
6711                                        case 7:
6712                                                {
6713                                                setState(820);
6714                                                th();
6715                                                }
6716                                                break;
6717                                        case 8:
6718                                                {
6719                                                setState(821);
6720                                                body();
6721                                                }
6722                                                break;
6723                                        case 9:
6724                                                {
6725                                                setState(822);
6726                                                colgroup();
6727                                                }
6728                                                break;
6729                                        case 10:
6730                                                {
6731                                                setState(823);
6732                                                dt();
6733                                                }
6734                                                break;
6735                                        case 11:
6736                                                {
6737                                                setState(824);
6738                                                head();
6739                                                }
6740                                                break;
6741                                        case 12:
6742                                                {
6743                                                setState(825);
6744                                                html();
6745                                                }
6746                                                break;
6747                                        case 13:
6748                                                {
6749                                                setState(826);
6750                                                option();
6751                                                }
6752                                                break;
6753                                        case 14:
6754                                                {
6755                                                setState(827);
6756                                                tbody();
6757                                                }
6758                                                break;
6759                                        case 15:
6760                                                {
6761                                                setState(828);
6762                                                thead();
6763                                                }
6764                                                break;
6765                                        case 16:
6766                                                {
6767                                                setState(829);
6768                                                tfoot();
6769                                                }
6770                                                break;
6771                                        case 17:
6772                                                {
6773                                                setState(830);
6774                                                pTagOpen();
6775                                                }
6776                                                break;
6777                                        case 18:
6778                                                {
6779                                                setState(831);
6780                                                liTagOpen();
6781                                                }
6782                                                break;
6783                                        case 19:
6784                                                {
6785                                                setState(832);
6786                                                trTagOpen();
6787                                                }
6788                                                break;
6789                                        case 20:
6790                                                {
6791                                                setState(833);
6792                                                tdTagOpen();
6793                                                }
6794                                                break;
6795                                        case 21:
6796                                                {
6797                                                setState(834);
6798                                                thTagOpen();
6799                                                }
6800                                                break;
6801                                        case 22:
6802                                                {
6803                                                setState(835);
6804                                                bodyTagOpen();
6805                                                }
6806                                                break;
6807                                        case 23:
6808                                                {
6809                                                setState(836);
6810                                                colgroupTagOpen();
6811                                                }
6812                                                break;
6813                                        case 24:
6814                                                {
6815                                                setState(837);
6816                                                dtTagOpen();
6817                                                }
6818                                                break;
6819                                        case 25:
6820                                                {
6821                                                setState(838);
6822                                                headTagOpen();
6823                                                }
6824                                                break;
6825                                        case 26:
6826                                                {
6827                                                setState(839);
6828                                                htmlTagOpen();
6829                                                }
6830                                                break;
6831                                        case 27:
6832                                                {
6833                                                setState(840);
6834                                                optionTagOpen();
6835                                                }
6836                                                break;
6837                                        case 28:
6838                                                {
6839                                                setState(841);
6840                                                tbodyTagOpen();
6841                                                }
6842                                                break;
6843                                        case 29:
6844                                                {
6845                                                setState(842);
6846                                                theadTagOpen();
6847                                                }
6848                                                break;
6849                                        case 30:
6850                                                {
6851                                                setState(843);
6852                                                tfootTagOpen();
6853                                                }
6854                                                break;
6855                                        case 31:
6856                                                {
6857                                                {
6858                                                setState(844);
6859                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6860                                                setState(845);
6861                                                match(LEADING_ASTERISK);
6862                                                }
6863                                                }
6864                                                break;
6865                                        case 32:
6866                                                {
6867                                                setState(846);
6868                                                htmlComment();
6869                                                }
6870                                                break;
6871                                        case 33:
6872                                                {
6873                                                setState(847);
6874                                                match(CDATA);
6875                                                }
6876                                                break;
6877                                        case 34:
6878                                                {
6879                                                setState(848);
6880                                                match(NEWLINE);
6881                                                }
6882                                                break;
6883                                        case 35:
6884                                                {
6885                                                setState(849);
6886                                                text();
6887                                                }
6888                                                break;
6889                                        case 36:
6890                                                {
6891                                                setState(850);
6892                                                javadocInlineTag();
6893                                                }
6894                                                break;
6895                                        }
6896                                        } 
6897                                }
6898                                setState(855);
6899                                _errHandler.sync(this);
6900                                _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6901                        }
6902                        setState(856);
6903                        ddTagClose();
6904                        }
6905                }
6906                catch (RecognitionException re) {
6907                        _localctx.exception = re;
6908                        _errHandler.reportError(this, re);
6909                        _errHandler.recover(this, re);
6910                }
6911                finally {
6912                        exitRule();
6913                }
6914                return _localctx;
6915        }
6916
6917        public static class DtTagOpenContext extends ParserRuleContext {
6918                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6919                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6920                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6921                public List<AttributeContext> attribute() {
6922                        return getRuleContexts(AttributeContext.class);
6923                }
6924                public AttributeContext attribute(int i) {
6925                        return getRuleContext(AttributeContext.class,i);
6926                }
6927                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6928                public TerminalNode NEWLINE(int i) {
6929                        return getToken(JavadocParser.NEWLINE, i);
6930                }
6931                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6932                public TerminalNode LEADING_ASTERISK(int i) {
6933                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6934                }
6935                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6936                public TerminalNode WS(int i) {
6937                        return getToken(JavadocParser.WS, i);
6938                }
6939                public DtTagOpenContext(ParserRuleContext parent, int invokingState) {
6940                        super(parent, invokingState);
6941                }
6942                @Override public int getRuleIndex() { return RULE_dtTagOpen; }
6943                @Override
6944                public void enterRule(ParseTreeListener listener) {
6945                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this);
6946                }
6947                @Override
6948                public void exitRule(ParseTreeListener listener) {
6949                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this);
6950                }
6951                @Override
6952                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6953                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this);
6954                        else return visitor.visitChildren(this);
6955                }
6956        }
6957
6958        public final DtTagOpenContext dtTagOpen() throws RecognitionException {
6959                DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState());
6960                enterRule(_localctx, 60, RULE_dtTagOpen);
6961                int _la;
6962                try {
6963                        enterOuterAlt(_localctx, 1);
6964                        {
6965                        setState(858);
6966                        match(OPEN);
6967                        setState(859);
6968                        match(DT_HTML_TAG_NAME);
6969                        setState(866);
6970                        _errHandler.sync(this);
6971                        _la = _input.LA(1);
6972                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6973                                {
6974                                setState(864);
6975                                switch (_input.LA(1)) {
6976                                case HTML_TAG_NAME:
6977                                        {
6978                                        setState(860);
6979                                        attribute();
6980                                        }
6981                                        break;
6982                                case NEWLINE:
6983                                        {
6984                                        setState(861);
6985                                        match(NEWLINE);
6986                                        }
6987                                        break;
6988                                case LEADING_ASTERISK:
6989                                        {
6990                                        setState(862);
6991                                        match(LEADING_ASTERISK);
6992                                        }
6993                                        break;
6994                                case WS:
6995                                        {
6996                                        setState(863);
6997                                        match(WS);
6998                                        }
6999                                        break;
7000                                default:
7001                                        throw new NoViableAltException(this);
7002                                }
7003                                }
7004                                setState(868);
7005                                _errHandler.sync(this);
7006                                _la = _input.LA(1);
7007                        }
7008                        setState(869);
7009                        match(CLOSE);
7010                        }
7011                }
7012                catch (RecognitionException re) {
7013                        _localctx.exception = re;
7014                        _errHandler.reportError(this, re);
7015                        _errHandler.recover(this, re);
7016                }
7017                finally {
7018                        exitRule();
7019                }
7020                return _localctx;
7021        }
7022
7023        public static class DtTagCloseContext extends ParserRuleContext {
7024                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7025                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7026                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
7027                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7028                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7029                public TerminalNode NEWLINE(int i) {
7030                        return getToken(JavadocParser.NEWLINE, i);
7031                }
7032                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7033                public TerminalNode LEADING_ASTERISK(int i) {
7034                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7035                }
7036                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7037                public TerminalNode WS(int i) {
7038                        return getToken(JavadocParser.WS, i);
7039                }
7040                public DtTagCloseContext(ParserRuleContext parent, int invokingState) {
7041                        super(parent, invokingState);
7042                }
7043                @Override public int getRuleIndex() { return RULE_dtTagClose; }
7044                @Override
7045                public void enterRule(ParseTreeListener listener) {
7046                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this);
7047                }
7048                @Override
7049                public void exitRule(ParseTreeListener listener) {
7050                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this);
7051                }
7052                @Override
7053                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7054                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this);
7055                        else return visitor.visitChildren(this);
7056                }
7057        }
7058
7059        public final DtTagCloseContext dtTagClose() throws RecognitionException {
7060                DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState());
7061                enterRule(_localctx, 62, RULE_dtTagClose);
7062                int _la;
7063                try {
7064                        enterOuterAlt(_localctx, 1);
7065                        {
7066                        setState(871);
7067                        match(OPEN);
7068                        setState(872);
7069                        match(SLASH);
7070                        setState(873);
7071                        match(DT_HTML_TAG_NAME);
7072                        setState(877);
7073                        _errHandler.sync(this);
7074                        _la = _input.LA(1);
7075                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7076                                {
7077                                {
7078                                setState(874);
7079                                _la = _input.LA(1);
7080                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7081                                _errHandler.recoverInline(this);
7082                                } else {
7083                                        consume();
7084                                }
7085                                }
7086                                }
7087                                setState(879);
7088                                _errHandler.sync(this);
7089                                _la = _input.LA(1);
7090                        }
7091                        setState(880);
7092                        match(CLOSE);
7093                        }
7094                }
7095                catch (RecognitionException re) {
7096                        _localctx.exception = re;
7097                        _errHandler.reportError(this, re);
7098                        _errHandler.recover(this, re);
7099                }
7100                finally {
7101                        exitRule();
7102                }
7103                return _localctx;
7104        }
7105
7106        public static class DtContext extends ParserRuleContext {
7107                public DtTagOpenContext dtTagOpen() {
7108                        return getRuleContext(DtTagOpenContext.class,0);
7109                }
7110                public DtTagCloseContext dtTagClose() {
7111                        return getRuleContext(DtTagCloseContext.class,0);
7112                }
7113                public List<HtmlTagContext> htmlTag() {
7114                        return getRuleContexts(HtmlTagContext.class);
7115                }
7116                public HtmlTagContext htmlTag(int i) {
7117                        return getRuleContext(HtmlTagContext.class,i);
7118                }
7119                public List<SingletonTagContext> singletonTag() {
7120                        return getRuleContexts(SingletonTagContext.class);
7121                }
7122                public SingletonTagContext singletonTag(int i) {
7123                        return getRuleContext(SingletonTagContext.class,i);
7124                }
7125                public List<ParagraphContext> paragraph() {
7126                        return getRuleContexts(ParagraphContext.class);
7127                }
7128                public ParagraphContext paragraph(int i) {
7129                        return getRuleContext(ParagraphContext.class,i);
7130                }
7131                public List<LiContext> li() {
7132                        return getRuleContexts(LiContext.class);
7133                }
7134                public LiContext li(int i) {
7135                        return getRuleContext(LiContext.class,i);
7136                }
7137                public List<TrContext> tr() {
7138                        return getRuleContexts(TrContext.class);
7139                }
7140                public TrContext tr(int i) {
7141                        return getRuleContext(TrContext.class,i);
7142                }
7143                public List<TdContext> td() {
7144                        return getRuleContexts(TdContext.class);
7145                }
7146                public TdContext td(int i) {
7147                        return getRuleContext(TdContext.class,i);
7148                }
7149                public List<ThContext> th() {
7150                        return getRuleContexts(ThContext.class);
7151                }
7152                public ThContext th(int i) {
7153                        return getRuleContext(ThContext.class,i);
7154                }
7155                public List<BodyContext> body() {
7156                        return getRuleContexts(BodyContext.class);
7157                }
7158                public BodyContext body(int i) {
7159                        return getRuleContext(BodyContext.class,i);
7160                }
7161                public List<ColgroupContext> colgroup() {
7162                        return getRuleContexts(ColgroupContext.class);
7163                }
7164                public ColgroupContext colgroup(int i) {
7165                        return getRuleContext(ColgroupContext.class,i);
7166                }
7167                public List<DdContext> dd() {
7168                        return getRuleContexts(DdContext.class);
7169                }
7170                public DdContext dd(int i) {
7171                        return getRuleContext(DdContext.class,i);
7172                }
7173                public List<HeadContext> head() {
7174                        return getRuleContexts(HeadContext.class);
7175                }
7176                public HeadContext head(int i) {
7177                        return getRuleContext(HeadContext.class,i);
7178                }
7179                public List<HtmlContext> html() {
7180                        return getRuleContexts(HtmlContext.class);
7181                }
7182                public HtmlContext html(int i) {
7183                        return getRuleContext(HtmlContext.class,i);
7184                }
7185                public List<OptionContext> option() {
7186                        return getRuleContexts(OptionContext.class);
7187                }
7188                public OptionContext option(int i) {
7189                        return getRuleContext(OptionContext.class,i);
7190                }
7191                public List<TbodyContext> tbody() {
7192                        return getRuleContexts(TbodyContext.class);
7193                }
7194                public TbodyContext tbody(int i) {
7195                        return getRuleContext(TbodyContext.class,i);
7196                }
7197                public List<TheadContext> thead() {
7198                        return getRuleContexts(TheadContext.class);
7199                }
7200                public TheadContext thead(int i) {
7201                        return getRuleContext(TheadContext.class,i);
7202                }
7203                public List<TfootContext> tfoot() {
7204                        return getRuleContexts(TfootContext.class);
7205                }
7206                public TfootContext tfoot(int i) {
7207                        return getRuleContext(TfootContext.class,i);
7208                }
7209                public List<PTagOpenContext> pTagOpen() {
7210                        return getRuleContexts(PTagOpenContext.class);
7211                }
7212                public PTagOpenContext pTagOpen(int i) {
7213                        return getRuleContext(PTagOpenContext.class,i);
7214                }
7215                public List<LiTagOpenContext> liTagOpen() {
7216                        return getRuleContexts(LiTagOpenContext.class);
7217                }
7218                public LiTagOpenContext liTagOpen(int i) {
7219                        return getRuleContext(LiTagOpenContext.class,i);
7220                }
7221                public List<TrTagOpenContext> trTagOpen() {
7222                        return getRuleContexts(TrTagOpenContext.class);
7223                }
7224                public TrTagOpenContext trTagOpen(int i) {
7225                        return getRuleContext(TrTagOpenContext.class,i);
7226                }
7227                public List<TdTagOpenContext> tdTagOpen() {
7228                        return getRuleContexts(TdTagOpenContext.class);
7229                }
7230                public TdTagOpenContext tdTagOpen(int i) {
7231                        return getRuleContext(TdTagOpenContext.class,i);
7232                }
7233                public List<ThTagOpenContext> thTagOpen() {
7234                        return getRuleContexts(ThTagOpenContext.class);
7235                }
7236                public ThTagOpenContext thTagOpen(int i) {
7237                        return getRuleContext(ThTagOpenContext.class,i);
7238                }
7239                public List<BodyTagOpenContext> bodyTagOpen() {
7240                        return getRuleContexts(BodyTagOpenContext.class);
7241                }
7242                public BodyTagOpenContext bodyTagOpen(int i) {
7243                        return getRuleContext(BodyTagOpenContext.class,i);
7244                }
7245                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7246                        return getRuleContexts(ColgroupTagOpenContext.class);
7247                }
7248                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7249                        return getRuleContext(ColgroupTagOpenContext.class,i);
7250                }
7251                public List<DdTagOpenContext> ddTagOpen() {
7252                        return getRuleContexts(DdTagOpenContext.class);
7253                }
7254                public DdTagOpenContext ddTagOpen(int i) {
7255                        return getRuleContext(DdTagOpenContext.class,i);
7256                }
7257                public List<HeadTagOpenContext> headTagOpen() {
7258                        return getRuleContexts(HeadTagOpenContext.class);
7259                }
7260                public HeadTagOpenContext headTagOpen(int i) {
7261                        return getRuleContext(HeadTagOpenContext.class,i);
7262                }
7263                public List<HtmlTagOpenContext> htmlTagOpen() {
7264                        return getRuleContexts(HtmlTagOpenContext.class);
7265                }
7266                public HtmlTagOpenContext htmlTagOpen(int i) {
7267                        return getRuleContext(HtmlTagOpenContext.class,i);
7268                }
7269                public List<OptionTagOpenContext> optionTagOpen() {
7270                        return getRuleContexts(OptionTagOpenContext.class);
7271                }
7272                public OptionTagOpenContext optionTagOpen(int i) {
7273                        return getRuleContext(OptionTagOpenContext.class,i);
7274                }
7275                public List<TbodyTagOpenContext> tbodyTagOpen() {
7276                        return getRuleContexts(TbodyTagOpenContext.class);
7277                }
7278                public TbodyTagOpenContext tbodyTagOpen(int i) {
7279                        return getRuleContext(TbodyTagOpenContext.class,i);
7280                }
7281                public List<TheadTagOpenContext> theadTagOpen() {
7282                        return getRuleContexts(TheadTagOpenContext.class);
7283                }
7284                public TheadTagOpenContext theadTagOpen(int i) {
7285                        return getRuleContext(TheadTagOpenContext.class,i);
7286                }
7287                public List<TfootTagOpenContext> tfootTagOpen() {
7288                        return getRuleContexts(TfootTagOpenContext.class);
7289                }
7290                public TfootTagOpenContext tfootTagOpen(int i) {
7291                        return getRuleContext(TfootTagOpenContext.class,i);
7292                }
7293                public List<HtmlCommentContext> htmlComment() {
7294                        return getRuleContexts(HtmlCommentContext.class);
7295                }
7296                public HtmlCommentContext htmlComment(int i) {
7297                        return getRuleContext(HtmlCommentContext.class,i);
7298                }
7299                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7300                public TerminalNode CDATA(int i) {
7301                        return getToken(JavadocParser.CDATA, i);
7302                }
7303                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7304                public TerminalNode NEWLINE(int i) {
7305                        return getToken(JavadocParser.NEWLINE, i);
7306                }
7307                public List<TextContext> text() {
7308                        return getRuleContexts(TextContext.class);
7309                }
7310                public TextContext text(int i) {
7311                        return getRuleContext(TextContext.class,i);
7312                }
7313                public List<JavadocInlineTagContext> javadocInlineTag() {
7314                        return getRuleContexts(JavadocInlineTagContext.class);
7315                }
7316                public JavadocInlineTagContext javadocInlineTag(int i) {
7317                        return getRuleContext(JavadocInlineTagContext.class,i);
7318                }
7319                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7320                public TerminalNode LEADING_ASTERISK(int i) {
7321                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7322                }
7323                public DtContext(ParserRuleContext parent, int invokingState) {
7324                        super(parent, invokingState);
7325                }
7326                @Override public int getRuleIndex() { return RULE_dt; }
7327                @Override
7328                public void enterRule(ParseTreeListener listener) {
7329                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this);
7330                }
7331                @Override
7332                public void exitRule(ParseTreeListener listener) {
7333                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this);
7334                }
7335                @Override
7336                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7337                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this);
7338                        else return visitor.visitChildren(this);
7339                }
7340        }
7341
7342        public final DtContext dt() throws RecognitionException {
7343                DtContext _localctx = new DtContext(_ctx, getState());
7344                enterRule(_localctx, 64, RULE_dt);
7345                try {
7346                        int _alt;
7347                        enterOuterAlt(_localctx, 1);
7348                        {
7349                        setState(882);
7350                        dtTagOpen();
7351                        setState(922);
7352                        _errHandler.sync(this);
7353                        _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7354                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7355                                if ( _alt==1 ) {
7356                                        {
7357                                        setState(920);
7358                                        _errHandler.sync(this);
7359                                        switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
7360                                        case 1:
7361                                                {
7362                                                setState(883);
7363                                                htmlTag();
7364                                                }
7365                                                break;
7366                                        case 2:
7367                                                {
7368                                                setState(884);
7369                                                singletonTag();
7370                                                }
7371                                                break;
7372                                        case 3:
7373                                                {
7374                                                setState(885);
7375                                                paragraph();
7376                                                }
7377                                                break;
7378                                        case 4:
7379                                                {
7380                                                setState(886);
7381                                                li();
7382                                                }
7383                                                break;
7384                                        case 5:
7385                                                {
7386                                                setState(887);
7387                                                tr();
7388                                                }
7389                                                break;
7390                                        case 6:
7391                                                {
7392                                                setState(888);
7393                                                td();
7394                                                }
7395                                                break;
7396                                        case 7:
7397                                                {
7398                                                setState(889);
7399                                                th();
7400                                                }
7401                                                break;
7402                                        case 8:
7403                                                {
7404                                                setState(890);
7405                                                body();
7406                                                }
7407                                                break;
7408                                        case 9:
7409                                                {
7410                                                setState(891);
7411                                                colgroup();
7412                                                }
7413                                                break;
7414                                        case 10:
7415                                                {
7416                                                setState(892);
7417                                                dd();
7418                                                }
7419                                                break;
7420                                        case 11:
7421                                                {
7422                                                setState(893);
7423                                                head();
7424                                                }
7425                                                break;
7426                                        case 12:
7427                                                {
7428                                                setState(894);
7429                                                html();
7430                                                }
7431                                                break;
7432                                        case 13:
7433                                                {
7434                                                setState(895);
7435                                                option();
7436                                                }
7437                                                break;
7438                                        case 14:
7439                                                {
7440                                                setState(896);
7441                                                tbody();
7442                                                }
7443                                                break;
7444                                        case 15:
7445                                                {
7446                                                setState(897);
7447                                                thead();
7448                                                }
7449                                                break;
7450                                        case 16:
7451                                                {
7452                                                setState(898);
7453                                                tfoot();
7454                                                }
7455                                                break;
7456                                        case 17:
7457                                                {
7458                                                setState(899);
7459                                                pTagOpen();
7460                                                }
7461                                                break;
7462                                        case 18:
7463                                                {
7464                                                setState(900);
7465                                                liTagOpen();
7466                                                }
7467                                                break;
7468                                        case 19:
7469                                                {
7470                                                setState(901);
7471                                                trTagOpen();
7472                                                }
7473                                                break;
7474                                        case 20:
7475                                                {
7476                                                setState(902);
7477                                                tdTagOpen();
7478                                                }
7479                                                break;
7480                                        case 21:
7481                                                {
7482                                                setState(903);
7483                                                thTagOpen();
7484                                                }
7485                                                break;
7486                                        case 22:
7487                                                {
7488                                                setState(904);
7489                                                bodyTagOpen();
7490                                                }
7491                                                break;
7492                                        case 23:
7493                                                {
7494                                                setState(905);
7495                                                colgroupTagOpen();
7496                                                }
7497                                                break;
7498                                        case 24:
7499                                                {
7500                                                setState(906);
7501                                                ddTagOpen();
7502                                                }
7503                                                break;
7504                                        case 25:
7505                                                {
7506                                                setState(907);
7507                                                headTagOpen();
7508                                                }
7509                                                break;
7510                                        case 26:
7511                                                {
7512                                                setState(908);
7513                                                htmlTagOpen();
7514                                                }
7515                                                break;
7516                                        case 27:
7517                                                {
7518                                                setState(909);
7519                                                optionTagOpen();
7520                                                }
7521                                                break;
7522                                        case 28:
7523                                                {
7524                                                setState(910);
7525                                                tbodyTagOpen();
7526                                                }
7527                                                break;
7528                                        case 29:
7529                                                {
7530                                                setState(911);
7531                                                theadTagOpen();
7532                                                }
7533                                                break;
7534                                        case 30:
7535                                                {
7536                                                setState(912);
7537                                                tfootTagOpen();
7538                                                }
7539                                                break;
7540                                        case 31:
7541                                                {
7542                                                {
7543                                                setState(913);
7544                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7545                                                setState(914);
7546                                                match(LEADING_ASTERISK);
7547                                                }
7548                                                }
7549                                                break;
7550                                        case 32:
7551                                                {
7552                                                setState(915);
7553                                                htmlComment();
7554                                                }
7555                                                break;
7556                                        case 33:
7557                                                {
7558                                                setState(916);
7559                                                match(CDATA);
7560                                                }
7561                                                break;
7562                                        case 34:
7563                                                {
7564                                                setState(917);
7565                                                match(NEWLINE);
7566                                                }
7567                                                break;
7568                                        case 35:
7569                                                {
7570                                                setState(918);
7571                                                text();
7572                                                }
7573                                                break;
7574                                        case 36:
7575                                                {
7576                                                setState(919);
7577                                                javadocInlineTag();
7578                                                }
7579                                                break;
7580                                        }
7581                                        } 
7582                                }
7583                                setState(924);
7584                                _errHandler.sync(this);
7585                                _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7586                        }
7587                        setState(925);
7588                        dtTagClose();
7589                        }
7590                }
7591                catch (RecognitionException re) {
7592                        _localctx.exception = re;
7593                        _errHandler.reportError(this, re);
7594                        _errHandler.recover(this, re);
7595                }
7596                finally {
7597                        exitRule();
7598                }
7599                return _localctx;
7600        }
7601
7602        public static class HeadTagOpenContext extends ParserRuleContext {
7603                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7604                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7605                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7606                public List<AttributeContext> attribute() {
7607                        return getRuleContexts(AttributeContext.class);
7608                }
7609                public AttributeContext attribute(int i) {
7610                        return getRuleContext(AttributeContext.class,i);
7611                }
7612                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7613                public TerminalNode NEWLINE(int i) {
7614                        return getToken(JavadocParser.NEWLINE, i);
7615                }
7616                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7617                public TerminalNode LEADING_ASTERISK(int i) {
7618                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7619                }
7620                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7621                public TerminalNode WS(int i) {
7622                        return getToken(JavadocParser.WS, i);
7623                }
7624                public HeadTagOpenContext(ParserRuleContext parent, int invokingState) {
7625                        super(parent, invokingState);
7626                }
7627                @Override public int getRuleIndex() { return RULE_headTagOpen; }
7628                @Override
7629                public void enterRule(ParseTreeListener listener) {
7630                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this);
7631                }
7632                @Override
7633                public void exitRule(ParseTreeListener listener) {
7634                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this);
7635                }
7636                @Override
7637                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7638                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this);
7639                        else return visitor.visitChildren(this);
7640                }
7641        }
7642
7643        public final HeadTagOpenContext headTagOpen() throws RecognitionException {
7644                HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState());
7645                enterRule(_localctx, 66, RULE_headTagOpen);
7646                int _la;
7647                try {
7648                        enterOuterAlt(_localctx, 1);
7649                        {
7650                        setState(927);
7651                        match(OPEN);
7652                        setState(928);
7653                        match(HEAD_HTML_TAG_NAME);
7654                        setState(935);
7655                        _errHandler.sync(this);
7656                        _la = _input.LA(1);
7657                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7658                                {
7659                                setState(933);
7660                                switch (_input.LA(1)) {
7661                                case HTML_TAG_NAME:
7662                                        {
7663                                        setState(929);
7664                                        attribute();
7665                                        }
7666                                        break;
7667                                case NEWLINE:
7668                                        {
7669                                        setState(930);
7670                                        match(NEWLINE);
7671                                        }
7672                                        break;
7673                                case LEADING_ASTERISK:
7674                                        {
7675                                        setState(931);
7676                                        match(LEADING_ASTERISK);
7677                                        }
7678                                        break;
7679                                case WS:
7680                                        {
7681                                        setState(932);
7682                                        match(WS);
7683                                        }
7684                                        break;
7685                                default:
7686                                        throw new NoViableAltException(this);
7687                                }
7688                                }
7689                                setState(937);
7690                                _errHandler.sync(this);
7691                                _la = _input.LA(1);
7692                        }
7693                        setState(938);
7694                        match(CLOSE);
7695                        }
7696                }
7697                catch (RecognitionException re) {
7698                        _localctx.exception = re;
7699                        _errHandler.reportError(this, re);
7700                        _errHandler.recover(this, re);
7701                }
7702                finally {
7703                        exitRule();
7704                }
7705                return _localctx;
7706        }
7707
7708        public static class HeadTagCloseContext extends ParserRuleContext {
7709                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7710                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7711                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7712                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7713                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7714                public TerminalNode NEWLINE(int i) {
7715                        return getToken(JavadocParser.NEWLINE, i);
7716                }
7717                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7718                public TerminalNode LEADING_ASTERISK(int i) {
7719                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7720                }
7721                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7722                public TerminalNode WS(int i) {
7723                        return getToken(JavadocParser.WS, i);
7724                }
7725                public HeadTagCloseContext(ParserRuleContext parent, int invokingState) {
7726                        super(parent, invokingState);
7727                }
7728                @Override public int getRuleIndex() { return RULE_headTagClose; }
7729                @Override
7730                public void enterRule(ParseTreeListener listener) {
7731                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this);
7732                }
7733                @Override
7734                public void exitRule(ParseTreeListener listener) {
7735                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this);
7736                }
7737                @Override
7738                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7739                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this);
7740                        else return visitor.visitChildren(this);
7741                }
7742        }
7743
7744        public final HeadTagCloseContext headTagClose() throws RecognitionException {
7745                HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState());
7746                enterRule(_localctx, 68, RULE_headTagClose);
7747                int _la;
7748                try {
7749                        enterOuterAlt(_localctx, 1);
7750                        {
7751                        setState(940);
7752                        match(OPEN);
7753                        setState(941);
7754                        match(SLASH);
7755                        setState(942);
7756                        match(HEAD_HTML_TAG_NAME);
7757                        setState(946);
7758                        _errHandler.sync(this);
7759                        _la = _input.LA(1);
7760                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7761                                {
7762                                {
7763                                setState(943);
7764                                _la = _input.LA(1);
7765                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7766                                _errHandler.recoverInline(this);
7767                                } else {
7768                                        consume();
7769                                }
7770                                }
7771                                }
7772                                setState(948);
7773                                _errHandler.sync(this);
7774                                _la = _input.LA(1);
7775                        }
7776                        setState(949);
7777                        match(CLOSE);
7778                        }
7779                }
7780                catch (RecognitionException re) {
7781                        _localctx.exception = re;
7782                        _errHandler.reportError(this, re);
7783                        _errHandler.recover(this, re);
7784                }
7785                finally {
7786                        exitRule();
7787                }
7788                return _localctx;
7789        }
7790
7791        public static class HeadContext extends ParserRuleContext {
7792                public HeadTagOpenContext headTagOpen() {
7793                        return getRuleContext(HeadTagOpenContext.class,0);
7794                }
7795                public HeadTagCloseContext headTagClose() {
7796                        return getRuleContext(HeadTagCloseContext.class,0);
7797                }
7798                public List<HtmlTagContext> htmlTag() {
7799                        return getRuleContexts(HtmlTagContext.class);
7800                }
7801                public HtmlTagContext htmlTag(int i) {
7802                        return getRuleContext(HtmlTagContext.class,i);
7803                }
7804                public List<SingletonTagContext> singletonTag() {
7805                        return getRuleContexts(SingletonTagContext.class);
7806                }
7807                public SingletonTagContext singletonTag(int i) {
7808                        return getRuleContext(SingletonTagContext.class,i);
7809                }
7810                public List<ParagraphContext> paragraph() {
7811                        return getRuleContexts(ParagraphContext.class);
7812                }
7813                public ParagraphContext paragraph(int i) {
7814                        return getRuleContext(ParagraphContext.class,i);
7815                }
7816                public List<LiContext> li() {
7817                        return getRuleContexts(LiContext.class);
7818                }
7819                public LiContext li(int i) {
7820                        return getRuleContext(LiContext.class,i);
7821                }
7822                public List<TrContext> tr() {
7823                        return getRuleContexts(TrContext.class);
7824                }
7825                public TrContext tr(int i) {
7826                        return getRuleContext(TrContext.class,i);
7827                }
7828                public List<TdContext> td() {
7829                        return getRuleContexts(TdContext.class);
7830                }
7831                public TdContext td(int i) {
7832                        return getRuleContext(TdContext.class,i);
7833                }
7834                public List<ThContext> th() {
7835                        return getRuleContexts(ThContext.class);
7836                }
7837                public ThContext th(int i) {
7838                        return getRuleContext(ThContext.class,i);
7839                }
7840                public List<BodyContext> body() {
7841                        return getRuleContexts(BodyContext.class);
7842                }
7843                public BodyContext body(int i) {
7844                        return getRuleContext(BodyContext.class,i);
7845                }
7846                public List<ColgroupContext> colgroup() {
7847                        return getRuleContexts(ColgroupContext.class);
7848                }
7849                public ColgroupContext colgroup(int i) {
7850                        return getRuleContext(ColgroupContext.class,i);
7851                }
7852                public List<DdContext> dd() {
7853                        return getRuleContexts(DdContext.class);
7854                }
7855                public DdContext dd(int i) {
7856                        return getRuleContext(DdContext.class,i);
7857                }
7858                public List<DtContext> dt() {
7859                        return getRuleContexts(DtContext.class);
7860                }
7861                public DtContext dt(int i) {
7862                        return getRuleContext(DtContext.class,i);
7863                }
7864                public List<HtmlContext> html() {
7865                        return getRuleContexts(HtmlContext.class);
7866                }
7867                public HtmlContext html(int i) {
7868                        return getRuleContext(HtmlContext.class,i);
7869                }
7870                public List<OptionContext> option() {
7871                        return getRuleContexts(OptionContext.class);
7872                }
7873                public OptionContext option(int i) {
7874                        return getRuleContext(OptionContext.class,i);
7875                }
7876                public List<TbodyContext> tbody() {
7877                        return getRuleContexts(TbodyContext.class);
7878                }
7879                public TbodyContext tbody(int i) {
7880                        return getRuleContext(TbodyContext.class,i);
7881                }
7882                public List<TheadContext> thead() {
7883                        return getRuleContexts(TheadContext.class);
7884                }
7885                public TheadContext thead(int i) {
7886                        return getRuleContext(TheadContext.class,i);
7887                }
7888                public List<TfootContext> tfoot() {
7889                        return getRuleContexts(TfootContext.class);
7890                }
7891                public TfootContext tfoot(int i) {
7892                        return getRuleContext(TfootContext.class,i);
7893                }
7894                public List<PTagOpenContext> pTagOpen() {
7895                        return getRuleContexts(PTagOpenContext.class);
7896                }
7897                public PTagOpenContext pTagOpen(int i) {
7898                        return getRuleContext(PTagOpenContext.class,i);
7899                }
7900                public List<LiTagOpenContext> liTagOpen() {
7901                        return getRuleContexts(LiTagOpenContext.class);
7902                }
7903                public LiTagOpenContext liTagOpen(int i) {
7904                        return getRuleContext(LiTagOpenContext.class,i);
7905                }
7906                public List<TrTagOpenContext> trTagOpen() {
7907                        return getRuleContexts(TrTagOpenContext.class);
7908                }
7909                public TrTagOpenContext trTagOpen(int i) {
7910                        return getRuleContext(TrTagOpenContext.class,i);
7911                }
7912                public List<TdTagOpenContext> tdTagOpen() {
7913                        return getRuleContexts(TdTagOpenContext.class);
7914                }
7915                public TdTagOpenContext tdTagOpen(int i) {
7916                        return getRuleContext(TdTagOpenContext.class,i);
7917                }
7918                public List<ThTagOpenContext> thTagOpen() {
7919                        return getRuleContexts(ThTagOpenContext.class);
7920                }
7921                public ThTagOpenContext thTagOpen(int i) {
7922                        return getRuleContext(ThTagOpenContext.class,i);
7923                }
7924                public List<BodyTagOpenContext> bodyTagOpen() {
7925                        return getRuleContexts(BodyTagOpenContext.class);
7926                }
7927                public BodyTagOpenContext bodyTagOpen(int i) {
7928                        return getRuleContext(BodyTagOpenContext.class,i);
7929                }
7930                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7931                        return getRuleContexts(ColgroupTagOpenContext.class);
7932                }
7933                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7934                        return getRuleContext(ColgroupTagOpenContext.class,i);
7935                }
7936                public List<DdTagOpenContext> ddTagOpen() {
7937                        return getRuleContexts(DdTagOpenContext.class);
7938                }
7939                public DdTagOpenContext ddTagOpen(int i) {
7940                        return getRuleContext(DdTagOpenContext.class,i);
7941                }
7942                public List<DtTagOpenContext> dtTagOpen() {
7943                        return getRuleContexts(DtTagOpenContext.class);
7944                }
7945                public DtTagOpenContext dtTagOpen(int i) {
7946                        return getRuleContext(DtTagOpenContext.class,i);
7947                }
7948                public List<HtmlTagOpenContext> htmlTagOpen() {
7949                        return getRuleContexts(HtmlTagOpenContext.class);
7950                }
7951                public HtmlTagOpenContext htmlTagOpen(int i) {
7952                        return getRuleContext(HtmlTagOpenContext.class,i);
7953                }
7954                public List<OptionTagOpenContext> optionTagOpen() {
7955                        return getRuleContexts(OptionTagOpenContext.class);
7956                }
7957                public OptionTagOpenContext optionTagOpen(int i) {
7958                        return getRuleContext(OptionTagOpenContext.class,i);
7959                }
7960                public List<TbodyTagOpenContext> tbodyTagOpen() {
7961                        return getRuleContexts(TbodyTagOpenContext.class);
7962                }
7963                public TbodyTagOpenContext tbodyTagOpen(int i) {
7964                        return getRuleContext(TbodyTagOpenContext.class,i);
7965                }
7966                public List<TheadTagOpenContext> theadTagOpen() {
7967                        return getRuleContexts(TheadTagOpenContext.class);
7968                }
7969                public TheadTagOpenContext theadTagOpen(int i) {
7970                        return getRuleContext(TheadTagOpenContext.class,i);
7971                }
7972                public List<TfootTagOpenContext> tfootTagOpen() {
7973                        return getRuleContexts(TfootTagOpenContext.class);
7974                }
7975                public TfootTagOpenContext tfootTagOpen(int i) {
7976                        return getRuleContext(TfootTagOpenContext.class,i);
7977                }
7978                public List<HtmlCommentContext> htmlComment() {
7979                        return getRuleContexts(HtmlCommentContext.class);
7980                }
7981                public HtmlCommentContext htmlComment(int i) {
7982                        return getRuleContext(HtmlCommentContext.class,i);
7983                }
7984                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7985                public TerminalNode CDATA(int i) {
7986                        return getToken(JavadocParser.CDATA, i);
7987                }
7988                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7989                public TerminalNode NEWLINE(int i) {
7990                        return getToken(JavadocParser.NEWLINE, i);
7991                }
7992                public List<TextContext> text() {
7993                        return getRuleContexts(TextContext.class);
7994                }
7995                public TextContext text(int i) {
7996                        return getRuleContext(TextContext.class,i);
7997                }
7998                public List<JavadocInlineTagContext> javadocInlineTag() {
7999                        return getRuleContexts(JavadocInlineTagContext.class);
8000                }
8001                public JavadocInlineTagContext javadocInlineTag(int i) {
8002                        return getRuleContext(JavadocInlineTagContext.class,i);
8003                }
8004                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8005                public TerminalNode LEADING_ASTERISK(int i) {
8006                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8007                }
8008                public HeadContext(ParserRuleContext parent, int invokingState) {
8009                        super(parent, invokingState);
8010                }
8011                @Override public int getRuleIndex() { return RULE_head; }
8012                @Override
8013                public void enterRule(ParseTreeListener listener) {
8014                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this);
8015                }
8016                @Override
8017                public void exitRule(ParseTreeListener listener) {
8018                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this);
8019                }
8020                @Override
8021                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8022                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this);
8023                        else return visitor.visitChildren(this);
8024                }
8025        }
8026
8027        public final HeadContext head() throws RecognitionException {
8028                HeadContext _localctx = new HeadContext(_ctx, getState());
8029                enterRule(_localctx, 70, RULE_head);
8030                try {
8031                        int _alt;
8032                        enterOuterAlt(_localctx, 1);
8033                        {
8034                        setState(951);
8035                        headTagOpen();
8036                        setState(991);
8037                        _errHandler.sync(this);
8038                        _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8039                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8040                                if ( _alt==1 ) {
8041                                        {
8042                                        setState(989);
8043                                        _errHandler.sync(this);
8044                                        switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
8045                                        case 1:
8046                                                {
8047                                                setState(952);
8048                                                htmlTag();
8049                                                }
8050                                                break;
8051                                        case 2:
8052                                                {
8053                                                setState(953);
8054                                                singletonTag();
8055                                                }
8056                                                break;
8057                                        case 3:
8058                                                {
8059                                                setState(954);
8060                                                paragraph();
8061                                                }
8062                                                break;
8063                                        case 4:
8064                                                {
8065                                                setState(955);
8066                                                li();
8067                                                }
8068                                                break;
8069                                        case 5:
8070                                                {
8071                                                setState(956);
8072                                                tr();
8073                                                }
8074                                                break;
8075                                        case 6:
8076                                                {
8077                                                setState(957);
8078                                                td();
8079                                                }
8080                                                break;
8081                                        case 7:
8082                                                {
8083                                                setState(958);
8084                                                th();
8085                                                }
8086                                                break;
8087                                        case 8:
8088                                                {
8089                                                setState(959);
8090                                                body();
8091                                                }
8092                                                break;
8093                                        case 9:
8094                                                {
8095                                                setState(960);
8096                                                colgroup();
8097                                                }
8098                                                break;
8099                                        case 10:
8100                                                {
8101                                                setState(961);
8102                                                dd();
8103                                                }
8104                                                break;
8105                                        case 11:
8106                                                {
8107                                                setState(962);
8108                                                dt();
8109                                                }
8110                                                break;
8111                                        case 12:
8112                                                {
8113                                                setState(963);
8114                                                html();
8115                                                }
8116                                                break;
8117                                        case 13:
8118                                                {
8119                                                setState(964);
8120                                                option();
8121                                                }
8122                                                break;
8123                                        case 14:
8124                                                {
8125                                                setState(965);
8126                                                tbody();
8127                                                }
8128                                                break;
8129                                        case 15:
8130                                                {
8131                                                setState(966);
8132                                                thead();
8133                                                }
8134                                                break;
8135                                        case 16:
8136                                                {
8137                                                setState(967);
8138                                                tfoot();
8139                                                }
8140                                                break;
8141                                        case 17:
8142                                                {
8143                                                setState(968);
8144                                                pTagOpen();
8145                                                }
8146                                                break;
8147                                        case 18:
8148                                                {
8149                                                setState(969);
8150                                                liTagOpen();
8151                                                }
8152                                                break;
8153                                        case 19:
8154                                                {
8155                                                setState(970);
8156                                                trTagOpen();
8157                                                }
8158                                                break;
8159                                        case 20:
8160                                                {
8161                                                setState(971);
8162                                                tdTagOpen();
8163                                                }
8164                                                break;
8165                                        case 21:
8166                                                {
8167                                                setState(972);
8168                                                thTagOpen();
8169                                                }
8170                                                break;
8171                                        case 22:
8172                                                {
8173                                                setState(973);
8174                                                bodyTagOpen();
8175                                                }
8176                                                break;
8177                                        case 23:
8178                                                {
8179                                                setState(974);
8180                                                colgroupTagOpen();
8181                                                }
8182                                                break;
8183                                        case 24:
8184                                                {
8185                                                setState(975);
8186                                                ddTagOpen();
8187                                                }
8188                                                break;
8189                                        case 25:
8190                                                {
8191                                                setState(976);
8192                                                dtTagOpen();
8193                                                }
8194                                                break;
8195                                        case 26:
8196                                                {
8197                                                setState(977);
8198                                                htmlTagOpen();
8199                                                }
8200                                                break;
8201                                        case 27:
8202                                                {
8203                                                setState(978);
8204                                                optionTagOpen();
8205                                                }
8206                                                break;
8207                                        case 28:
8208                                                {
8209                                                setState(979);
8210                                                tbodyTagOpen();
8211                                                }
8212                                                break;
8213                                        case 29:
8214                                                {
8215                                                setState(980);
8216                                                theadTagOpen();
8217                                                }
8218                                                break;
8219                                        case 30:
8220                                                {
8221                                                setState(981);
8222                                                tfootTagOpen();
8223                                                }
8224                                                break;
8225                                        case 31:
8226                                                {
8227                                                {
8228                                                setState(982);
8229                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8230                                                setState(983);
8231                                                match(LEADING_ASTERISK);
8232                                                }
8233                                                }
8234                                                break;
8235                                        case 32:
8236                                                {
8237                                                setState(984);
8238                                                htmlComment();
8239                                                }
8240                                                break;
8241                                        case 33:
8242                                                {
8243                                                setState(985);
8244                                                match(CDATA);
8245                                                }
8246                                                break;
8247                                        case 34:
8248                                                {
8249                                                setState(986);
8250                                                match(NEWLINE);
8251                                                }
8252                                                break;
8253                                        case 35:
8254                                                {
8255                                                setState(987);
8256                                                text();
8257                                                }
8258                                                break;
8259                                        case 36:
8260                                                {
8261                                                setState(988);
8262                                                javadocInlineTag();
8263                                                }
8264                                                break;
8265                                        }
8266                                        } 
8267                                }
8268                                setState(993);
8269                                _errHandler.sync(this);
8270                                _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8271                        }
8272                        setState(994);
8273                        headTagClose();
8274                        }
8275                }
8276                catch (RecognitionException re) {
8277                        _localctx.exception = re;
8278                        _errHandler.reportError(this, re);
8279                        _errHandler.recover(this, re);
8280                }
8281                finally {
8282                        exitRule();
8283                }
8284                return _localctx;
8285        }
8286
8287        public static class HtmlTagOpenContext extends ParserRuleContext {
8288                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8289                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8290                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8291                public List<AttributeContext> attribute() {
8292                        return getRuleContexts(AttributeContext.class);
8293                }
8294                public AttributeContext attribute(int i) {
8295                        return getRuleContext(AttributeContext.class,i);
8296                }
8297                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8298                public TerminalNode NEWLINE(int i) {
8299                        return getToken(JavadocParser.NEWLINE, i);
8300                }
8301                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8302                public TerminalNode LEADING_ASTERISK(int i) {
8303                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8304                }
8305                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8306                public TerminalNode WS(int i) {
8307                        return getToken(JavadocParser.WS, i);
8308                }
8309                public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) {
8310                        super(parent, invokingState);
8311                }
8312                @Override public int getRuleIndex() { return RULE_htmlTagOpen; }
8313                @Override
8314                public void enterRule(ParseTreeListener listener) {
8315                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this);
8316                }
8317                @Override
8318                public void exitRule(ParseTreeListener listener) {
8319                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this);
8320                }
8321                @Override
8322                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8323                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this);
8324                        else return visitor.visitChildren(this);
8325                }
8326        }
8327
8328        public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException {
8329                HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState());
8330                enterRule(_localctx, 72, RULE_htmlTagOpen);
8331                int _la;
8332                try {
8333                        enterOuterAlt(_localctx, 1);
8334                        {
8335                        setState(996);
8336                        match(OPEN);
8337                        setState(997);
8338                        match(HTML_HTML_TAG_NAME);
8339                        setState(1004);
8340                        _errHandler.sync(this);
8341                        _la = _input.LA(1);
8342                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8343                                {
8344                                setState(1002);
8345                                switch (_input.LA(1)) {
8346                                case HTML_TAG_NAME:
8347                                        {
8348                                        setState(998);
8349                                        attribute();
8350                                        }
8351                                        break;
8352                                case NEWLINE:
8353                                        {
8354                                        setState(999);
8355                                        match(NEWLINE);
8356                                        }
8357                                        break;
8358                                case LEADING_ASTERISK:
8359                                        {
8360                                        setState(1000);
8361                                        match(LEADING_ASTERISK);
8362                                        }
8363                                        break;
8364                                case WS:
8365                                        {
8366                                        setState(1001);
8367                                        match(WS);
8368                                        }
8369                                        break;
8370                                default:
8371                                        throw new NoViableAltException(this);
8372                                }
8373                                }
8374                                setState(1006);
8375                                _errHandler.sync(this);
8376                                _la = _input.LA(1);
8377                        }
8378                        setState(1007);
8379                        match(CLOSE);
8380                        }
8381                }
8382                catch (RecognitionException re) {
8383                        _localctx.exception = re;
8384                        _errHandler.reportError(this, re);
8385                        _errHandler.recover(this, re);
8386                }
8387                finally {
8388                        exitRule();
8389                }
8390                return _localctx;
8391        }
8392
8393        public static class HtmlTagCloseContext extends ParserRuleContext {
8394                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8395                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8396                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8397                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8398                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8399                public TerminalNode NEWLINE(int i) {
8400                        return getToken(JavadocParser.NEWLINE, i);
8401                }
8402                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8403                public TerminalNode LEADING_ASTERISK(int i) {
8404                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8405                }
8406                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8407                public TerminalNode WS(int i) {
8408                        return getToken(JavadocParser.WS, i);
8409                }
8410                public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) {
8411                        super(parent, invokingState);
8412                }
8413                @Override public int getRuleIndex() { return RULE_htmlTagClose; }
8414                @Override
8415                public void enterRule(ParseTreeListener listener) {
8416                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this);
8417                }
8418                @Override
8419                public void exitRule(ParseTreeListener listener) {
8420                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this);
8421                }
8422                @Override
8423                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8424                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this);
8425                        else return visitor.visitChildren(this);
8426                }
8427        }
8428
8429        public final HtmlTagCloseContext htmlTagClose() throws RecognitionException {
8430                HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState());
8431                enterRule(_localctx, 74, RULE_htmlTagClose);
8432                int _la;
8433                try {
8434                        enterOuterAlt(_localctx, 1);
8435                        {
8436                        setState(1009);
8437                        match(OPEN);
8438                        setState(1010);
8439                        match(SLASH);
8440                        setState(1011);
8441                        match(HTML_HTML_TAG_NAME);
8442                        setState(1015);
8443                        _errHandler.sync(this);
8444                        _la = _input.LA(1);
8445                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8446                                {
8447                                {
8448                                setState(1012);
8449                                _la = _input.LA(1);
8450                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8451                                _errHandler.recoverInline(this);
8452                                } else {
8453                                        consume();
8454                                }
8455                                }
8456                                }
8457                                setState(1017);
8458                                _errHandler.sync(this);
8459                                _la = _input.LA(1);
8460                        }
8461                        setState(1018);
8462                        match(CLOSE);
8463                        }
8464                }
8465                catch (RecognitionException re) {
8466                        _localctx.exception = re;
8467                        _errHandler.reportError(this, re);
8468                        _errHandler.recover(this, re);
8469                }
8470                finally {
8471                        exitRule();
8472                }
8473                return _localctx;
8474        }
8475
8476        public static class HtmlContext extends ParserRuleContext {
8477                public HtmlTagOpenContext htmlTagOpen() {
8478                        return getRuleContext(HtmlTagOpenContext.class,0);
8479                }
8480                public HtmlTagCloseContext htmlTagClose() {
8481                        return getRuleContext(HtmlTagCloseContext.class,0);
8482                }
8483                public List<HtmlTagContext> htmlTag() {
8484                        return getRuleContexts(HtmlTagContext.class);
8485                }
8486                public HtmlTagContext htmlTag(int i) {
8487                        return getRuleContext(HtmlTagContext.class,i);
8488                }
8489                public List<SingletonTagContext> singletonTag() {
8490                        return getRuleContexts(SingletonTagContext.class);
8491                }
8492                public SingletonTagContext singletonTag(int i) {
8493                        return getRuleContext(SingletonTagContext.class,i);
8494                }
8495                public List<ParagraphContext> paragraph() {
8496                        return getRuleContexts(ParagraphContext.class);
8497                }
8498                public ParagraphContext paragraph(int i) {
8499                        return getRuleContext(ParagraphContext.class,i);
8500                }
8501                public List<LiContext> li() {
8502                        return getRuleContexts(LiContext.class);
8503                }
8504                public LiContext li(int i) {
8505                        return getRuleContext(LiContext.class,i);
8506                }
8507                public List<TrContext> tr() {
8508                        return getRuleContexts(TrContext.class);
8509                }
8510                public TrContext tr(int i) {
8511                        return getRuleContext(TrContext.class,i);
8512                }
8513                public List<TdContext> td() {
8514                        return getRuleContexts(TdContext.class);
8515                }
8516                public TdContext td(int i) {
8517                        return getRuleContext(TdContext.class,i);
8518                }
8519                public List<ThContext> th() {
8520                        return getRuleContexts(ThContext.class);
8521                }
8522                public ThContext th(int i) {
8523                        return getRuleContext(ThContext.class,i);
8524                }
8525                public List<BodyContext> body() {
8526                        return getRuleContexts(BodyContext.class);
8527                }
8528                public BodyContext body(int i) {
8529                        return getRuleContext(BodyContext.class,i);
8530                }
8531                public List<ColgroupContext> colgroup() {
8532                        return getRuleContexts(ColgroupContext.class);
8533                }
8534                public ColgroupContext colgroup(int i) {
8535                        return getRuleContext(ColgroupContext.class,i);
8536                }
8537                public List<DdContext> dd() {
8538                        return getRuleContexts(DdContext.class);
8539                }
8540                public DdContext dd(int i) {
8541                        return getRuleContext(DdContext.class,i);
8542                }
8543                public List<DtContext> dt() {
8544                        return getRuleContexts(DtContext.class);
8545                }
8546                public DtContext dt(int i) {
8547                        return getRuleContext(DtContext.class,i);
8548                }
8549                public List<HeadContext> head() {
8550                        return getRuleContexts(HeadContext.class);
8551                }
8552                public HeadContext head(int i) {
8553                        return getRuleContext(HeadContext.class,i);
8554                }
8555                public List<OptionContext> option() {
8556                        return getRuleContexts(OptionContext.class);
8557                }
8558                public OptionContext option(int i) {
8559                        return getRuleContext(OptionContext.class,i);
8560                }
8561                public List<TbodyContext> tbody() {
8562                        return getRuleContexts(TbodyContext.class);
8563                }
8564                public TbodyContext tbody(int i) {
8565                        return getRuleContext(TbodyContext.class,i);
8566                }
8567                public List<TheadContext> thead() {
8568                        return getRuleContexts(TheadContext.class);
8569                }
8570                public TheadContext thead(int i) {
8571                        return getRuleContext(TheadContext.class,i);
8572                }
8573                public List<TfootContext> tfoot() {
8574                        return getRuleContexts(TfootContext.class);
8575                }
8576                public TfootContext tfoot(int i) {
8577                        return getRuleContext(TfootContext.class,i);
8578                }
8579                public List<PTagOpenContext> pTagOpen() {
8580                        return getRuleContexts(PTagOpenContext.class);
8581                }
8582                public PTagOpenContext pTagOpen(int i) {
8583                        return getRuleContext(PTagOpenContext.class,i);
8584                }
8585                public List<LiTagOpenContext> liTagOpen() {
8586                        return getRuleContexts(LiTagOpenContext.class);
8587                }
8588                public LiTagOpenContext liTagOpen(int i) {
8589                        return getRuleContext(LiTagOpenContext.class,i);
8590                }
8591                public List<TrTagOpenContext> trTagOpen() {
8592                        return getRuleContexts(TrTagOpenContext.class);
8593                }
8594                public TrTagOpenContext trTagOpen(int i) {
8595                        return getRuleContext(TrTagOpenContext.class,i);
8596                }
8597                public List<TdTagOpenContext> tdTagOpen() {
8598                        return getRuleContexts(TdTagOpenContext.class);
8599                }
8600                public TdTagOpenContext tdTagOpen(int i) {
8601                        return getRuleContext(TdTagOpenContext.class,i);
8602                }
8603                public List<ThTagOpenContext> thTagOpen() {
8604                        return getRuleContexts(ThTagOpenContext.class);
8605                }
8606                public ThTagOpenContext thTagOpen(int i) {
8607                        return getRuleContext(ThTagOpenContext.class,i);
8608                }
8609                public List<BodyTagOpenContext> bodyTagOpen() {
8610                        return getRuleContexts(BodyTagOpenContext.class);
8611                }
8612                public BodyTagOpenContext bodyTagOpen(int i) {
8613                        return getRuleContext(BodyTagOpenContext.class,i);
8614                }
8615                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8616                        return getRuleContexts(ColgroupTagOpenContext.class);
8617                }
8618                public ColgroupTagOpenContext colgroupTagOpen(int i) {
8619                        return getRuleContext(ColgroupTagOpenContext.class,i);
8620                }
8621                public List<DdTagOpenContext> ddTagOpen() {
8622                        return getRuleContexts(DdTagOpenContext.class);
8623                }
8624                public DdTagOpenContext ddTagOpen(int i) {
8625                        return getRuleContext(DdTagOpenContext.class,i);
8626                }
8627                public List<DtTagOpenContext> dtTagOpen() {
8628                        return getRuleContexts(DtTagOpenContext.class);
8629                }
8630                public DtTagOpenContext dtTagOpen(int i) {
8631                        return getRuleContext(DtTagOpenContext.class,i);
8632                }
8633                public List<HeadTagOpenContext> headTagOpen() {
8634                        return getRuleContexts(HeadTagOpenContext.class);
8635                }
8636                public HeadTagOpenContext headTagOpen(int i) {
8637                        return getRuleContext(HeadTagOpenContext.class,i);
8638                }
8639                public List<OptionTagOpenContext> optionTagOpen() {
8640                        return getRuleContexts(OptionTagOpenContext.class);
8641                }
8642                public OptionTagOpenContext optionTagOpen(int i) {
8643                        return getRuleContext(OptionTagOpenContext.class,i);
8644                }
8645                public List<TbodyTagOpenContext> tbodyTagOpen() {
8646                        return getRuleContexts(TbodyTagOpenContext.class);
8647                }
8648                public TbodyTagOpenContext tbodyTagOpen(int i) {
8649                        return getRuleContext(TbodyTagOpenContext.class,i);
8650                }
8651                public List<TheadTagOpenContext> theadTagOpen() {
8652                        return getRuleContexts(TheadTagOpenContext.class);
8653                }
8654                public TheadTagOpenContext theadTagOpen(int i) {
8655                        return getRuleContext(TheadTagOpenContext.class,i);
8656                }
8657                public List<TfootTagOpenContext> tfootTagOpen() {
8658                        return getRuleContexts(TfootTagOpenContext.class);
8659                }
8660                public TfootTagOpenContext tfootTagOpen(int i) {
8661                        return getRuleContext(TfootTagOpenContext.class,i);
8662                }
8663                public List<HtmlCommentContext> htmlComment() {
8664                        return getRuleContexts(HtmlCommentContext.class);
8665                }
8666                public HtmlCommentContext htmlComment(int i) {
8667                        return getRuleContext(HtmlCommentContext.class,i);
8668                }
8669                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8670                public TerminalNode CDATA(int i) {
8671                        return getToken(JavadocParser.CDATA, i);
8672                }
8673                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8674                public TerminalNode NEWLINE(int i) {
8675                        return getToken(JavadocParser.NEWLINE, i);
8676                }
8677                public List<TextContext> text() {
8678                        return getRuleContexts(TextContext.class);
8679                }
8680                public TextContext text(int i) {
8681                        return getRuleContext(TextContext.class,i);
8682                }
8683                public List<JavadocInlineTagContext> javadocInlineTag() {
8684                        return getRuleContexts(JavadocInlineTagContext.class);
8685                }
8686                public JavadocInlineTagContext javadocInlineTag(int i) {
8687                        return getRuleContext(JavadocInlineTagContext.class,i);
8688                }
8689                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8690                public TerminalNode LEADING_ASTERISK(int i) {
8691                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8692                }
8693                public HtmlContext(ParserRuleContext parent, int invokingState) {
8694                        super(parent, invokingState);
8695                }
8696                @Override public int getRuleIndex() { return RULE_html; }
8697                @Override
8698                public void enterRule(ParseTreeListener listener) {
8699                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this);
8700                }
8701                @Override
8702                public void exitRule(ParseTreeListener listener) {
8703                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this);
8704                }
8705                @Override
8706                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8707                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this);
8708                        else return visitor.visitChildren(this);
8709                }
8710        }
8711
8712        public final HtmlContext html() throws RecognitionException {
8713                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8714                enterRule(_localctx, 76, RULE_html);
8715                try {
8716                        int _alt;
8717                        enterOuterAlt(_localctx, 1);
8718                        {
8719                        setState(1020);
8720                        htmlTagOpen();
8721                        setState(1060);
8722                        _errHandler.sync(this);
8723                        _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8724                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8725                                if ( _alt==1 ) {
8726                                        {
8727                                        setState(1058);
8728                                        _errHandler.sync(this);
8729                                        switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
8730                                        case 1:
8731                                                {
8732                                                setState(1021);
8733                                                htmlTag();
8734                                                }
8735                                                break;
8736                                        case 2:
8737                                                {
8738                                                setState(1022);
8739                                                singletonTag();
8740                                                }
8741                                                break;
8742                                        case 3:
8743                                                {
8744                                                setState(1023);
8745                                                paragraph();
8746                                                }
8747                                                break;
8748                                        case 4:
8749                                                {
8750                                                setState(1024);
8751                                                li();
8752                                                }
8753                                                break;
8754                                        case 5:
8755                                                {
8756                                                setState(1025);
8757                                                tr();
8758                                                }
8759                                                break;
8760                                        case 6:
8761                                                {
8762                                                setState(1026);
8763                                                td();
8764                                                }
8765                                                break;
8766                                        case 7:
8767                                                {
8768                                                setState(1027);
8769                                                th();
8770                                                }
8771                                                break;
8772                                        case 8:
8773                                                {
8774                                                setState(1028);
8775                                                body();
8776                                                }
8777                                                break;
8778                                        case 9:
8779                                                {
8780                                                setState(1029);
8781                                                colgroup();
8782                                                }
8783                                                break;
8784                                        case 10:
8785                                                {
8786                                                setState(1030);
8787                                                dd();
8788                                                }
8789                                                break;
8790                                        case 11:
8791                                                {
8792                                                setState(1031);
8793                                                dt();
8794                                                }
8795                                                break;
8796                                        case 12:
8797                                                {
8798                                                setState(1032);
8799                                                head();
8800                                                }
8801                                                break;
8802                                        case 13:
8803                                                {
8804                                                setState(1033);
8805                                                option();
8806                                                }
8807                                                break;
8808                                        case 14:
8809                                                {
8810                                                setState(1034);
8811                                                tbody();
8812                                                }
8813                                                break;
8814                                        case 15:
8815                                                {
8816                                                setState(1035);
8817                                                thead();
8818                                                }
8819                                                break;
8820                                        case 16:
8821                                                {
8822                                                setState(1036);
8823                                                tfoot();
8824                                                }
8825                                                break;
8826                                        case 17:
8827                                                {
8828                                                setState(1037);
8829                                                pTagOpen();
8830                                                }
8831                                                break;
8832                                        case 18:
8833                                                {
8834                                                setState(1038);
8835                                                liTagOpen();
8836                                                }
8837                                                break;
8838                                        case 19:
8839                                                {
8840                                                setState(1039);
8841                                                trTagOpen();
8842                                                }
8843                                                break;
8844                                        case 20:
8845                                                {
8846                                                setState(1040);
8847                                                tdTagOpen();
8848                                                }
8849                                                break;
8850                                        case 21:
8851                                                {
8852                                                setState(1041);
8853                                                thTagOpen();
8854                                                }
8855                                                break;
8856                                        case 22:
8857                                                {
8858                                                setState(1042);
8859                                                bodyTagOpen();
8860                                                }
8861                                                break;
8862                                        case 23:
8863                                                {
8864                                                setState(1043);
8865                                                colgroupTagOpen();
8866                                                }
8867                                                break;
8868                                        case 24:
8869                                                {
8870                                                setState(1044);
8871                                                ddTagOpen();
8872                                                }
8873                                                break;
8874                                        case 25:
8875                                                {
8876                                                setState(1045);
8877                                                dtTagOpen();
8878                                                }
8879                                                break;
8880                                        case 26:
8881                                                {
8882                                                setState(1046);
8883                                                headTagOpen();
8884                                                }
8885                                                break;
8886                                        case 27:
8887                                                {
8888                                                setState(1047);
8889                                                optionTagOpen();
8890                                                }
8891                                                break;
8892                                        case 28:
8893                                                {
8894                                                setState(1048);
8895                                                tbodyTagOpen();
8896                                                }
8897                                                break;
8898                                        case 29:
8899                                                {
8900                                                setState(1049);
8901                                                theadTagOpen();
8902                                                }
8903                                                break;
8904                                        case 30:
8905                                                {
8906                                                setState(1050);
8907                                                tfootTagOpen();
8908                                                }
8909                                                break;
8910                                        case 31:
8911                                                {
8912                                                {
8913                                                setState(1051);
8914                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8915                                                setState(1052);
8916                                                match(LEADING_ASTERISK);
8917                                                }
8918                                                }
8919                                                break;
8920                                        case 32:
8921                                                {
8922                                                setState(1053);
8923                                                htmlComment();
8924                                                }
8925                                                break;
8926                                        case 33:
8927                                                {
8928                                                setState(1054);
8929                                                match(CDATA);
8930                                                }
8931                                                break;
8932                                        case 34:
8933                                                {
8934                                                setState(1055);
8935                                                match(NEWLINE);
8936                                                }
8937                                                break;
8938                                        case 35:
8939                                                {
8940                                                setState(1056);
8941                                                text();
8942                                                }
8943                                                break;
8944                                        case 36:
8945                                                {
8946                                                setState(1057);
8947                                                javadocInlineTag();
8948                                                }
8949                                                break;
8950                                        }
8951                                        } 
8952                                }
8953                                setState(1062);
8954                                _errHandler.sync(this);
8955                                _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8956                        }
8957                        setState(1063);
8958                        htmlTagClose();
8959                        }
8960                }
8961                catch (RecognitionException re) {
8962                        _localctx.exception = re;
8963                        _errHandler.reportError(this, re);
8964                        _errHandler.recover(this, re);
8965                }
8966                finally {
8967                        exitRule();
8968                }
8969                return _localctx;
8970        }
8971
8972        public static class OptionTagOpenContext extends ParserRuleContext {
8973                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8974                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8975                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8976                public List<AttributeContext> attribute() {
8977                        return getRuleContexts(AttributeContext.class);
8978                }
8979                public AttributeContext attribute(int i) {
8980                        return getRuleContext(AttributeContext.class,i);
8981                }
8982                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8983                public TerminalNode NEWLINE(int i) {
8984                        return getToken(JavadocParser.NEWLINE, i);
8985                }
8986                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8987                public TerminalNode LEADING_ASTERISK(int i) {
8988                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8989                }
8990                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8991                public TerminalNode WS(int i) {
8992                        return getToken(JavadocParser.WS, i);
8993                }
8994                public OptionTagOpenContext(ParserRuleContext parent, int invokingState) {
8995                        super(parent, invokingState);
8996                }
8997                @Override public int getRuleIndex() { return RULE_optionTagOpen; }
8998                @Override
8999                public void enterRule(ParseTreeListener listener) {
9000                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this);
9001                }
9002                @Override
9003                public void exitRule(ParseTreeListener listener) {
9004                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this);
9005                }
9006                @Override
9007                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9008                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this);
9009                        else return visitor.visitChildren(this);
9010                }
9011        }
9012
9013        public final OptionTagOpenContext optionTagOpen() throws RecognitionException {
9014                OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState());
9015                enterRule(_localctx, 78, RULE_optionTagOpen);
9016                int _la;
9017                try {
9018                        enterOuterAlt(_localctx, 1);
9019                        {
9020                        setState(1065);
9021                        match(OPEN);
9022                        setState(1066);
9023                        match(OPTION_HTML_TAG_NAME);
9024                        setState(1073);
9025                        _errHandler.sync(this);
9026                        _la = _input.LA(1);
9027                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9028                                {
9029                                setState(1071);
9030                                switch (_input.LA(1)) {
9031                                case HTML_TAG_NAME:
9032                                        {
9033                                        setState(1067);
9034                                        attribute();
9035                                        }
9036                                        break;
9037                                case NEWLINE:
9038                                        {
9039                                        setState(1068);
9040                                        match(NEWLINE);
9041                                        }
9042                                        break;
9043                                case LEADING_ASTERISK:
9044                                        {
9045                                        setState(1069);
9046                                        match(LEADING_ASTERISK);
9047                                        }
9048                                        break;
9049                                case WS:
9050                                        {
9051                                        setState(1070);
9052                                        match(WS);
9053                                        }
9054                                        break;
9055                                default:
9056                                        throw new NoViableAltException(this);
9057                                }
9058                                }
9059                                setState(1075);
9060                                _errHandler.sync(this);
9061                                _la = _input.LA(1);
9062                        }
9063                        setState(1076);
9064                        match(CLOSE);
9065                        }
9066                }
9067                catch (RecognitionException re) {
9068                        _localctx.exception = re;
9069                        _errHandler.reportError(this, re);
9070                        _errHandler.recover(this, re);
9071                }
9072                finally {
9073                        exitRule();
9074                }
9075                return _localctx;
9076        }
9077
9078        public static class OptionTagCloseContext extends ParserRuleContext {
9079                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9080                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9081                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9082                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9083                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9084                public TerminalNode NEWLINE(int i) {
9085                        return getToken(JavadocParser.NEWLINE, i);
9086                }
9087                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9088                public TerminalNode LEADING_ASTERISK(int i) {
9089                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9090                }
9091                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9092                public TerminalNode WS(int i) {
9093                        return getToken(JavadocParser.WS, i);
9094                }
9095                public OptionTagCloseContext(ParserRuleContext parent, int invokingState) {
9096                        super(parent, invokingState);
9097                }
9098                @Override public int getRuleIndex() { return RULE_optionTagClose; }
9099                @Override
9100                public void enterRule(ParseTreeListener listener) {
9101                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this);
9102                }
9103                @Override
9104                public void exitRule(ParseTreeListener listener) {
9105                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this);
9106                }
9107                @Override
9108                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9109                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this);
9110                        else return visitor.visitChildren(this);
9111                }
9112        }
9113
9114        public final OptionTagCloseContext optionTagClose() throws RecognitionException {
9115                OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState());
9116                enterRule(_localctx, 80, RULE_optionTagClose);
9117                int _la;
9118                try {
9119                        enterOuterAlt(_localctx, 1);
9120                        {
9121                        setState(1078);
9122                        match(OPEN);
9123                        setState(1079);
9124                        match(SLASH);
9125                        setState(1080);
9126                        match(OPTION_HTML_TAG_NAME);
9127                        setState(1084);
9128                        _errHandler.sync(this);
9129                        _la = _input.LA(1);
9130                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9131                                {
9132                                {
9133                                setState(1081);
9134                                _la = _input.LA(1);
9135                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9136                                _errHandler.recoverInline(this);
9137                                } else {
9138                                        consume();
9139                                }
9140                                }
9141                                }
9142                                setState(1086);
9143                                _errHandler.sync(this);
9144                                _la = _input.LA(1);
9145                        }
9146                        setState(1087);
9147                        match(CLOSE);
9148                        }
9149                }
9150                catch (RecognitionException re) {
9151                        _localctx.exception = re;
9152                        _errHandler.reportError(this, re);
9153                        _errHandler.recover(this, re);
9154                }
9155                finally {
9156                        exitRule();
9157                }
9158                return _localctx;
9159        }
9160
9161        public static class OptionContext extends ParserRuleContext {
9162                public OptionTagOpenContext optionTagOpen() {
9163                        return getRuleContext(OptionTagOpenContext.class,0);
9164                }
9165                public OptionTagCloseContext optionTagClose() {
9166                        return getRuleContext(OptionTagCloseContext.class,0);
9167                }
9168                public List<HtmlTagContext> htmlTag() {
9169                        return getRuleContexts(HtmlTagContext.class);
9170                }
9171                public HtmlTagContext htmlTag(int i) {
9172                        return getRuleContext(HtmlTagContext.class,i);
9173                }
9174                public List<SingletonTagContext> singletonTag() {
9175                        return getRuleContexts(SingletonTagContext.class);
9176                }
9177                public SingletonTagContext singletonTag(int i) {
9178                        return getRuleContext(SingletonTagContext.class,i);
9179                }
9180                public List<ParagraphContext> paragraph() {
9181                        return getRuleContexts(ParagraphContext.class);
9182                }
9183                public ParagraphContext paragraph(int i) {
9184                        return getRuleContext(ParagraphContext.class,i);
9185                }
9186                public List<LiContext> li() {
9187                        return getRuleContexts(LiContext.class);
9188                }
9189                public LiContext li(int i) {
9190                        return getRuleContext(LiContext.class,i);
9191                }
9192                public List<TrContext> tr() {
9193                        return getRuleContexts(TrContext.class);
9194                }
9195                public TrContext tr(int i) {
9196                        return getRuleContext(TrContext.class,i);
9197                }
9198                public List<TdContext> td() {
9199                        return getRuleContexts(TdContext.class);
9200                }
9201                public TdContext td(int i) {
9202                        return getRuleContext(TdContext.class,i);
9203                }
9204                public List<ThContext> th() {
9205                        return getRuleContexts(ThContext.class);
9206                }
9207                public ThContext th(int i) {
9208                        return getRuleContext(ThContext.class,i);
9209                }
9210                public List<BodyContext> body() {
9211                        return getRuleContexts(BodyContext.class);
9212                }
9213                public BodyContext body(int i) {
9214                        return getRuleContext(BodyContext.class,i);
9215                }
9216                public List<ColgroupContext> colgroup() {
9217                        return getRuleContexts(ColgroupContext.class);
9218                }
9219                public ColgroupContext colgroup(int i) {
9220                        return getRuleContext(ColgroupContext.class,i);
9221                }
9222                public List<DdContext> dd() {
9223                        return getRuleContexts(DdContext.class);
9224                }
9225                public DdContext dd(int i) {
9226                        return getRuleContext(DdContext.class,i);
9227                }
9228                public List<DtContext> dt() {
9229                        return getRuleContexts(DtContext.class);
9230                }
9231                public DtContext dt(int i) {
9232                        return getRuleContext(DtContext.class,i);
9233                }
9234                public List<HeadContext> head() {
9235                        return getRuleContexts(HeadContext.class);
9236                }
9237                public HeadContext head(int i) {
9238                        return getRuleContext(HeadContext.class,i);
9239                }
9240                public List<HtmlContext> html() {
9241                        return getRuleContexts(HtmlContext.class);
9242                }
9243                public HtmlContext html(int i) {
9244                        return getRuleContext(HtmlContext.class,i);
9245                }
9246                public List<TbodyContext> tbody() {
9247                        return getRuleContexts(TbodyContext.class);
9248                }
9249                public TbodyContext tbody(int i) {
9250                        return getRuleContext(TbodyContext.class,i);
9251                }
9252                public List<TheadContext> thead() {
9253                        return getRuleContexts(TheadContext.class);
9254                }
9255                public TheadContext thead(int i) {
9256                        return getRuleContext(TheadContext.class,i);
9257                }
9258                public List<TfootContext> tfoot() {
9259                        return getRuleContexts(TfootContext.class);
9260                }
9261                public TfootContext tfoot(int i) {
9262                        return getRuleContext(TfootContext.class,i);
9263                }
9264                public List<PTagOpenContext> pTagOpen() {
9265                        return getRuleContexts(PTagOpenContext.class);
9266                }
9267                public PTagOpenContext pTagOpen(int i) {
9268                        return getRuleContext(PTagOpenContext.class,i);
9269                }
9270                public List<LiTagOpenContext> liTagOpen() {
9271                        return getRuleContexts(LiTagOpenContext.class);
9272                }
9273                public LiTagOpenContext liTagOpen(int i) {
9274                        return getRuleContext(LiTagOpenContext.class,i);
9275                }
9276                public List<TrTagOpenContext> trTagOpen() {
9277                        return getRuleContexts(TrTagOpenContext.class);
9278                }
9279                public TrTagOpenContext trTagOpen(int i) {
9280                        return getRuleContext(TrTagOpenContext.class,i);
9281                }
9282                public List<TdTagOpenContext> tdTagOpen() {
9283                        return getRuleContexts(TdTagOpenContext.class);
9284                }
9285                public TdTagOpenContext tdTagOpen(int i) {
9286                        return getRuleContext(TdTagOpenContext.class,i);
9287                }
9288                public List<ThTagOpenContext> thTagOpen() {
9289                        return getRuleContexts(ThTagOpenContext.class);
9290                }
9291                public ThTagOpenContext thTagOpen(int i) {
9292                        return getRuleContext(ThTagOpenContext.class,i);
9293                }
9294                public List<BodyTagOpenContext> bodyTagOpen() {
9295                        return getRuleContexts(BodyTagOpenContext.class);
9296                }
9297                public BodyTagOpenContext bodyTagOpen(int i) {
9298                        return getRuleContext(BodyTagOpenContext.class,i);
9299                }
9300                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9301                        return getRuleContexts(ColgroupTagOpenContext.class);
9302                }
9303                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9304                        return getRuleContext(ColgroupTagOpenContext.class,i);
9305                }
9306                public List<DdTagOpenContext> ddTagOpen() {
9307                        return getRuleContexts(DdTagOpenContext.class);
9308                }
9309                public DdTagOpenContext ddTagOpen(int i) {
9310                        return getRuleContext(DdTagOpenContext.class,i);
9311                }
9312                public List<DtTagOpenContext> dtTagOpen() {
9313                        return getRuleContexts(DtTagOpenContext.class);
9314                }
9315                public DtTagOpenContext dtTagOpen(int i) {
9316                        return getRuleContext(DtTagOpenContext.class,i);
9317                }
9318                public List<HeadTagOpenContext> headTagOpen() {
9319                        return getRuleContexts(HeadTagOpenContext.class);
9320                }
9321                public HeadTagOpenContext headTagOpen(int i) {
9322                        return getRuleContext(HeadTagOpenContext.class,i);
9323                }
9324                public List<HtmlTagOpenContext> htmlTagOpen() {
9325                        return getRuleContexts(HtmlTagOpenContext.class);
9326                }
9327                public HtmlTagOpenContext htmlTagOpen(int i) {
9328                        return getRuleContext(HtmlTagOpenContext.class,i);
9329                }
9330                public List<TbodyTagOpenContext> tbodyTagOpen() {
9331                        return getRuleContexts(TbodyTagOpenContext.class);
9332                }
9333                public TbodyTagOpenContext tbodyTagOpen(int i) {
9334                        return getRuleContext(TbodyTagOpenContext.class,i);
9335                }
9336                public List<TheadTagOpenContext> theadTagOpen() {
9337                        return getRuleContexts(TheadTagOpenContext.class);
9338                }
9339                public TheadTagOpenContext theadTagOpen(int i) {
9340                        return getRuleContext(TheadTagOpenContext.class,i);
9341                }
9342                public List<TfootTagOpenContext> tfootTagOpen() {
9343                        return getRuleContexts(TfootTagOpenContext.class);
9344                }
9345                public TfootTagOpenContext tfootTagOpen(int i) {
9346                        return getRuleContext(TfootTagOpenContext.class,i);
9347                }
9348                public List<HtmlCommentContext> htmlComment() {
9349                        return getRuleContexts(HtmlCommentContext.class);
9350                }
9351                public HtmlCommentContext htmlComment(int i) {
9352                        return getRuleContext(HtmlCommentContext.class,i);
9353                }
9354                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9355                public TerminalNode CDATA(int i) {
9356                        return getToken(JavadocParser.CDATA, i);
9357                }
9358                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9359                public TerminalNode NEWLINE(int i) {
9360                        return getToken(JavadocParser.NEWLINE, i);
9361                }
9362                public List<TextContext> text() {
9363                        return getRuleContexts(TextContext.class);
9364                }
9365                public TextContext text(int i) {
9366                        return getRuleContext(TextContext.class,i);
9367                }
9368                public List<JavadocInlineTagContext> javadocInlineTag() {
9369                        return getRuleContexts(JavadocInlineTagContext.class);
9370                }
9371                public JavadocInlineTagContext javadocInlineTag(int i) {
9372                        return getRuleContext(JavadocInlineTagContext.class,i);
9373                }
9374                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9375                public TerminalNode LEADING_ASTERISK(int i) {
9376                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9377                }
9378                public OptionContext(ParserRuleContext parent, int invokingState) {
9379                        super(parent, invokingState);
9380                }
9381                @Override public int getRuleIndex() { return RULE_option; }
9382                @Override
9383                public void enterRule(ParseTreeListener listener) {
9384                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this);
9385                }
9386                @Override
9387                public void exitRule(ParseTreeListener listener) {
9388                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this);
9389                }
9390                @Override
9391                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9392                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this);
9393                        else return visitor.visitChildren(this);
9394                }
9395        }
9396
9397        public final OptionContext option() throws RecognitionException {
9398                OptionContext _localctx = new OptionContext(_ctx, getState());
9399                enterRule(_localctx, 82, RULE_option);
9400                try {
9401                        int _alt;
9402                        enterOuterAlt(_localctx, 1);
9403                        {
9404                        setState(1089);
9405                        optionTagOpen();
9406                        setState(1129);
9407                        _errHandler.sync(this);
9408                        _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9409                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9410                                if ( _alt==1 ) {
9411                                        {
9412                                        setState(1127);
9413                                        _errHandler.sync(this);
9414                                        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
9415                                        case 1:
9416                                                {
9417                                                setState(1090);
9418                                                htmlTag();
9419                                                }
9420                                                break;
9421                                        case 2:
9422                                                {
9423                                                setState(1091);
9424                                                singletonTag();
9425                                                }
9426                                                break;
9427                                        case 3:
9428                                                {
9429                                                setState(1092);
9430                                                paragraph();
9431                                                }
9432                                                break;
9433                                        case 4:
9434                                                {
9435                                                setState(1093);
9436                                                li();
9437                                                }
9438                                                break;
9439                                        case 5:
9440                                                {
9441                                                setState(1094);
9442                                                tr();
9443                                                }
9444                                                break;
9445                                        case 6:
9446                                                {
9447                                                setState(1095);
9448                                                td();
9449                                                }
9450                                                break;
9451                                        case 7:
9452                                                {
9453                                                setState(1096);
9454                                                th();
9455                                                }
9456                                                break;
9457                                        case 8:
9458                                                {
9459                                                setState(1097);
9460                                                body();
9461                                                }
9462                                                break;
9463                                        case 9:
9464                                                {
9465                                                setState(1098);
9466                                                colgroup();
9467                                                }
9468                                                break;
9469                                        case 10:
9470                                                {
9471                                                setState(1099);
9472                                                dd();
9473                                                }
9474                                                break;
9475                                        case 11:
9476                                                {
9477                                                setState(1100);
9478                                                dt();
9479                                                }
9480                                                break;
9481                                        case 12:
9482                                                {
9483                                                setState(1101);
9484                                                head();
9485                                                }
9486                                                break;
9487                                        case 13:
9488                                                {
9489                                                setState(1102);
9490                                                html();
9491                                                }
9492                                                break;
9493                                        case 14:
9494                                                {
9495                                                setState(1103);
9496                                                tbody();
9497                                                }
9498                                                break;
9499                                        case 15:
9500                                                {
9501                                                setState(1104);
9502                                                thead();
9503                                                }
9504                                                break;
9505                                        case 16:
9506                                                {
9507                                                setState(1105);
9508                                                tfoot();
9509                                                }
9510                                                break;
9511                                        case 17:
9512                                                {
9513                                                setState(1106);
9514                                                pTagOpen();
9515                                                }
9516                                                break;
9517                                        case 18:
9518                                                {
9519                                                setState(1107);
9520                                                liTagOpen();
9521                                                }
9522                                                break;
9523                                        case 19:
9524                                                {
9525                                                setState(1108);
9526                                                trTagOpen();
9527                                                }
9528                                                break;
9529                                        case 20:
9530                                                {
9531                                                setState(1109);
9532                                                tdTagOpen();
9533                                                }
9534                                                break;
9535                                        case 21:
9536                                                {
9537                                                setState(1110);
9538                                                thTagOpen();
9539                                                }
9540                                                break;
9541                                        case 22:
9542                                                {
9543                                                setState(1111);
9544                                                bodyTagOpen();
9545                                                }
9546                                                break;
9547                                        case 23:
9548                                                {
9549                                                setState(1112);
9550                                                colgroupTagOpen();
9551                                                }
9552                                                break;
9553                                        case 24:
9554                                                {
9555                                                setState(1113);
9556                                                ddTagOpen();
9557                                                }
9558                                                break;
9559                                        case 25:
9560                                                {
9561                                                setState(1114);
9562                                                dtTagOpen();
9563                                                }
9564                                                break;
9565                                        case 26:
9566                                                {
9567                                                setState(1115);
9568                                                headTagOpen();
9569                                                }
9570                                                break;
9571                                        case 27:
9572                                                {
9573                                                setState(1116);
9574                                                htmlTagOpen();
9575                                                }
9576                                                break;
9577                                        case 28:
9578                                                {
9579                                                setState(1117);
9580                                                tbodyTagOpen();
9581                                                }
9582                                                break;
9583                                        case 29:
9584                                                {
9585                                                setState(1118);
9586                                                theadTagOpen();
9587                                                }
9588                                                break;
9589                                        case 30:
9590                                                {
9591                                                setState(1119);
9592                                                tfootTagOpen();
9593                                                }
9594                                                break;
9595                                        case 31:
9596                                                {
9597                                                {
9598                                                setState(1120);
9599                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9600                                                setState(1121);
9601                                                match(LEADING_ASTERISK);
9602                                                }
9603                                                }
9604                                                break;
9605                                        case 32:
9606                                                {
9607                                                setState(1122);
9608                                                htmlComment();
9609                                                }
9610                                                break;
9611                                        case 33:
9612                                                {
9613                                                setState(1123);
9614                                                match(CDATA);
9615                                                }
9616                                                break;
9617                                        case 34:
9618                                                {
9619                                                setState(1124);
9620                                                match(NEWLINE);
9621                                                }
9622                                                break;
9623                                        case 35:
9624                                                {
9625                                                setState(1125);
9626                                                text();
9627                                                }
9628                                                break;
9629                                        case 36:
9630                                                {
9631                                                setState(1126);
9632                                                javadocInlineTag();
9633                                                }
9634                                                break;
9635                                        }
9636                                        } 
9637                                }
9638                                setState(1131);
9639                                _errHandler.sync(this);
9640                                _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9641                        }
9642                        setState(1132);
9643                        optionTagClose();
9644                        }
9645                }
9646                catch (RecognitionException re) {
9647                        _localctx.exception = re;
9648                        _errHandler.reportError(this, re);
9649                        _errHandler.recover(this, re);
9650                }
9651                finally {
9652                        exitRule();
9653                }
9654                return _localctx;
9655        }
9656
9657        public static class TbodyTagOpenContext extends ParserRuleContext {
9658                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9659                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9660                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9661                public List<AttributeContext> attribute() {
9662                        return getRuleContexts(AttributeContext.class);
9663                }
9664                public AttributeContext attribute(int i) {
9665                        return getRuleContext(AttributeContext.class,i);
9666                }
9667                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9668                public TerminalNode NEWLINE(int i) {
9669                        return getToken(JavadocParser.NEWLINE, i);
9670                }
9671                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9672                public TerminalNode LEADING_ASTERISK(int i) {
9673                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9674                }
9675                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9676                public TerminalNode WS(int i) {
9677                        return getToken(JavadocParser.WS, i);
9678                }
9679                public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) {
9680                        super(parent, invokingState);
9681                }
9682                @Override public int getRuleIndex() { return RULE_tbodyTagOpen; }
9683                @Override
9684                public void enterRule(ParseTreeListener listener) {
9685                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this);
9686                }
9687                @Override
9688                public void exitRule(ParseTreeListener listener) {
9689                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this);
9690                }
9691                @Override
9692                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9693                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this);
9694                        else return visitor.visitChildren(this);
9695                }
9696        }
9697
9698        public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException {
9699                TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState());
9700                enterRule(_localctx, 84, RULE_tbodyTagOpen);
9701                int _la;
9702                try {
9703                        enterOuterAlt(_localctx, 1);
9704                        {
9705                        setState(1134);
9706                        match(OPEN);
9707                        setState(1135);
9708                        match(TBODY_HTML_TAG_NAME);
9709                        setState(1142);
9710                        _errHandler.sync(this);
9711                        _la = _input.LA(1);
9712                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9713                                {
9714                                setState(1140);
9715                                switch (_input.LA(1)) {
9716                                case HTML_TAG_NAME:
9717                                        {
9718                                        setState(1136);
9719                                        attribute();
9720                                        }
9721                                        break;
9722                                case NEWLINE:
9723                                        {
9724                                        setState(1137);
9725                                        match(NEWLINE);
9726                                        }
9727                                        break;
9728                                case LEADING_ASTERISK:
9729                                        {
9730                                        setState(1138);
9731                                        match(LEADING_ASTERISK);
9732                                        }
9733                                        break;
9734                                case WS:
9735                                        {
9736                                        setState(1139);
9737                                        match(WS);
9738                                        }
9739                                        break;
9740                                default:
9741                                        throw new NoViableAltException(this);
9742                                }
9743                                }
9744                                setState(1144);
9745                                _errHandler.sync(this);
9746                                _la = _input.LA(1);
9747                        }
9748                        setState(1145);
9749                        match(CLOSE);
9750                        }
9751                }
9752                catch (RecognitionException re) {
9753                        _localctx.exception = re;
9754                        _errHandler.reportError(this, re);
9755                        _errHandler.recover(this, re);
9756                }
9757                finally {
9758                        exitRule();
9759                }
9760                return _localctx;
9761        }
9762
9763        public static class TbodyTagCloseContext extends ParserRuleContext {
9764                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9765                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9766                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9767                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9768                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9769                public TerminalNode NEWLINE(int i) {
9770                        return getToken(JavadocParser.NEWLINE, i);
9771                }
9772                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9773                public TerminalNode LEADING_ASTERISK(int i) {
9774                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9775                }
9776                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9777                public TerminalNode WS(int i) {
9778                        return getToken(JavadocParser.WS, i);
9779                }
9780                public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) {
9781                        super(parent, invokingState);
9782                }
9783                @Override public int getRuleIndex() { return RULE_tbodyTagClose; }
9784                @Override
9785                public void enterRule(ParseTreeListener listener) {
9786                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this);
9787                }
9788                @Override
9789                public void exitRule(ParseTreeListener listener) {
9790                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this);
9791                }
9792                @Override
9793                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9794                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this);
9795                        else return visitor.visitChildren(this);
9796                }
9797        }
9798
9799        public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException {
9800                TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState());
9801                enterRule(_localctx, 86, RULE_tbodyTagClose);
9802                int _la;
9803                try {
9804                        enterOuterAlt(_localctx, 1);
9805                        {
9806                        setState(1147);
9807                        match(OPEN);
9808                        setState(1148);
9809                        match(SLASH);
9810                        setState(1149);
9811                        match(TBODY_HTML_TAG_NAME);
9812                        setState(1153);
9813                        _errHandler.sync(this);
9814                        _la = _input.LA(1);
9815                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9816                                {
9817                                {
9818                                setState(1150);
9819                                _la = _input.LA(1);
9820                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9821                                _errHandler.recoverInline(this);
9822                                } else {
9823                                        consume();
9824                                }
9825                                }
9826                                }
9827                                setState(1155);
9828                                _errHandler.sync(this);
9829                                _la = _input.LA(1);
9830                        }
9831                        setState(1156);
9832                        match(CLOSE);
9833                        }
9834                }
9835                catch (RecognitionException re) {
9836                        _localctx.exception = re;
9837                        _errHandler.reportError(this, re);
9838                        _errHandler.recover(this, re);
9839                }
9840                finally {
9841                        exitRule();
9842                }
9843                return _localctx;
9844        }
9845
9846        public static class TbodyContext extends ParserRuleContext {
9847                public TbodyTagOpenContext tbodyTagOpen() {
9848                        return getRuleContext(TbodyTagOpenContext.class,0);
9849                }
9850                public TbodyTagCloseContext tbodyTagClose() {
9851                        return getRuleContext(TbodyTagCloseContext.class,0);
9852                }
9853                public List<HtmlTagContext> htmlTag() {
9854                        return getRuleContexts(HtmlTagContext.class);
9855                }
9856                public HtmlTagContext htmlTag(int i) {
9857                        return getRuleContext(HtmlTagContext.class,i);
9858                }
9859                public List<SingletonTagContext> singletonTag() {
9860                        return getRuleContexts(SingletonTagContext.class);
9861                }
9862                public SingletonTagContext singletonTag(int i) {
9863                        return getRuleContext(SingletonTagContext.class,i);
9864                }
9865                public List<ParagraphContext> paragraph() {
9866                        return getRuleContexts(ParagraphContext.class);
9867                }
9868                public ParagraphContext paragraph(int i) {
9869                        return getRuleContext(ParagraphContext.class,i);
9870                }
9871                public List<LiContext> li() {
9872                        return getRuleContexts(LiContext.class);
9873                }
9874                public LiContext li(int i) {
9875                        return getRuleContext(LiContext.class,i);
9876                }
9877                public List<TrContext> tr() {
9878                        return getRuleContexts(TrContext.class);
9879                }
9880                public TrContext tr(int i) {
9881                        return getRuleContext(TrContext.class,i);
9882                }
9883                public List<TdContext> td() {
9884                        return getRuleContexts(TdContext.class);
9885                }
9886                public TdContext td(int i) {
9887                        return getRuleContext(TdContext.class,i);
9888                }
9889                public List<ThContext> th() {
9890                        return getRuleContexts(ThContext.class);
9891                }
9892                public ThContext th(int i) {
9893                        return getRuleContext(ThContext.class,i);
9894                }
9895                public List<BodyContext> body() {
9896                        return getRuleContexts(BodyContext.class);
9897                }
9898                public BodyContext body(int i) {
9899                        return getRuleContext(BodyContext.class,i);
9900                }
9901                public List<ColgroupContext> colgroup() {
9902                        return getRuleContexts(ColgroupContext.class);
9903                }
9904                public ColgroupContext colgroup(int i) {
9905                        return getRuleContext(ColgroupContext.class,i);
9906                }
9907                public List<DdContext> dd() {
9908                        return getRuleContexts(DdContext.class);
9909                }
9910                public DdContext dd(int i) {
9911                        return getRuleContext(DdContext.class,i);
9912                }
9913                public List<DtContext> dt() {
9914                        return getRuleContexts(DtContext.class);
9915                }
9916                public DtContext dt(int i) {
9917                        return getRuleContext(DtContext.class,i);
9918                }
9919                public List<HeadContext> head() {
9920                        return getRuleContexts(HeadContext.class);
9921                }
9922                public HeadContext head(int i) {
9923                        return getRuleContext(HeadContext.class,i);
9924                }
9925                public List<HtmlContext> html() {
9926                        return getRuleContexts(HtmlContext.class);
9927                }
9928                public HtmlContext html(int i) {
9929                        return getRuleContext(HtmlContext.class,i);
9930                }
9931                public List<OptionContext> option() {
9932                        return getRuleContexts(OptionContext.class);
9933                }
9934                public OptionContext option(int i) {
9935                        return getRuleContext(OptionContext.class,i);
9936                }
9937                public List<TheadContext> thead() {
9938                        return getRuleContexts(TheadContext.class);
9939                }
9940                public TheadContext thead(int i) {
9941                        return getRuleContext(TheadContext.class,i);
9942                }
9943                public List<TfootContext> tfoot() {
9944                        return getRuleContexts(TfootContext.class);
9945                }
9946                public TfootContext tfoot(int i) {
9947                        return getRuleContext(TfootContext.class,i);
9948                }
9949                public List<PTagOpenContext> pTagOpen() {
9950                        return getRuleContexts(PTagOpenContext.class);
9951                }
9952                public PTagOpenContext pTagOpen(int i) {
9953                        return getRuleContext(PTagOpenContext.class,i);
9954                }
9955                public List<LiTagOpenContext> liTagOpen() {
9956                        return getRuleContexts(LiTagOpenContext.class);
9957                }
9958                public LiTagOpenContext liTagOpen(int i) {
9959                        return getRuleContext(LiTagOpenContext.class,i);
9960                }
9961                public List<TrTagOpenContext> trTagOpen() {
9962                        return getRuleContexts(TrTagOpenContext.class);
9963                }
9964                public TrTagOpenContext trTagOpen(int i) {
9965                        return getRuleContext(TrTagOpenContext.class,i);
9966                }
9967                public List<TdTagOpenContext> tdTagOpen() {
9968                        return getRuleContexts(TdTagOpenContext.class);
9969                }
9970                public TdTagOpenContext tdTagOpen(int i) {
9971                        return getRuleContext(TdTagOpenContext.class,i);
9972                }
9973                public List<ThTagOpenContext> thTagOpen() {
9974                        return getRuleContexts(ThTagOpenContext.class);
9975                }
9976                public ThTagOpenContext thTagOpen(int i) {
9977                        return getRuleContext(ThTagOpenContext.class,i);
9978                }
9979                public List<BodyTagOpenContext> bodyTagOpen() {
9980                        return getRuleContexts(BodyTagOpenContext.class);
9981                }
9982                public BodyTagOpenContext bodyTagOpen(int i) {
9983                        return getRuleContext(BodyTagOpenContext.class,i);
9984                }
9985                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9986                        return getRuleContexts(ColgroupTagOpenContext.class);
9987                }
9988                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9989                        return getRuleContext(ColgroupTagOpenContext.class,i);
9990                }
9991                public List<DdTagOpenContext> ddTagOpen() {
9992                        return getRuleContexts(DdTagOpenContext.class);
9993                }
9994                public DdTagOpenContext ddTagOpen(int i) {
9995                        return getRuleContext(DdTagOpenContext.class,i);
9996                }
9997                public List<DtTagOpenContext> dtTagOpen() {
9998                        return getRuleContexts(DtTagOpenContext.class);
9999                }
10000                public DtTagOpenContext dtTagOpen(int i) {
10001                        return getRuleContext(DtTagOpenContext.class,i);
10002                }
10003                public List<HeadTagOpenContext> headTagOpen() {
10004                        return getRuleContexts(HeadTagOpenContext.class);
10005                }
10006                public HeadTagOpenContext headTagOpen(int i) {
10007                        return getRuleContext(HeadTagOpenContext.class,i);
10008                }
10009                public List<HtmlTagOpenContext> htmlTagOpen() {
10010                        return getRuleContexts(HtmlTagOpenContext.class);
10011                }
10012                public HtmlTagOpenContext htmlTagOpen(int i) {
10013                        return getRuleContext(HtmlTagOpenContext.class,i);
10014                }
10015                public List<OptionTagOpenContext> optionTagOpen() {
10016                        return getRuleContexts(OptionTagOpenContext.class);
10017                }
10018                public OptionTagOpenContext optionTagOpen(int i) {
10019                        return getRuleContext(OptionTagOpenContext.class,i);
10020                }
10021                public List<TheadTagOpenContext> theadTagOpen() {
10022                        return getRuleContexts(TheadTagOpenContext.class);
10023                }
10024                public TheadTagOpenContext theadTagOpen(int i) {
10025                        return getRuleContext(TheadTagOpenContext.class,i);
10026                }
10027                public List<TfootTagOpenContext> tfootTagOpen() {
10028                        return getRuleContexts(TfootTagOpenContext.class);
10029                }
10030                public TfootTagOpenContext tfootTagOpen(int i) {
10031                        return getRuleContext(TfootTagOpenContext.class,i);
10032                }
10033                public List<HtmlCommentContext> htmlComment() {
10034                        return getRuleContexts(HtmlCommentContext.class);
10035                }
10036                public HtmlCommentContext htmlComment(int i) {
10037                        return getRuleContext(HtmlCommentContext.class,i);
10038                }
10039                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10040                public TerminalNode CDATA(int i) {
10041                        return getToken(JavadocParser.CDATA, i);
10042                }
10043                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10044                public TerminalNode NEWLINE(int i) {
10045                        return getToken(JavadocParser.NEWLINE, i);
10046                }
10047                public List<TextContext> text() {
10048                        return getRuleContexts(TextContext.class);
10049                }
10050                public TextContext text(int i) {
10051                        return getRuleContext(TextContext.class,i);
10052                }
10053                public List<JavadocInlineTagContext> javadocInlineTag() {
10054                        return getRuleContexts(JavadocInlineTagContext.class);
10055                }
10056                public JavadocInlineTagContext javadocInlineTag(int i) {
10057                        return getRuleContext(JavadocInlineTagContext.class,i);
10058                }
10059                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10060                public TerminalNode LEADING_ASTERISK(int i) {
10061                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10062                }
10063                public TbodyContext(ParserRuleContext parent, int invokingState) {
10064                        super(parent, invokingState);
10065                }
10066                @Override public int getRuleIndex() { return RULE_tbody; }
10067                @Override
10068                public void enterRule(ParseTreeListener listener) {
10069                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this);
10070                }
10071                @Override
10072                public void exitRule(ParseTreeListener listener) {
10073                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this);
10074                }
10075                @Override
10076                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10077                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this);
10078                        else return visitor.visitChildren(this);
10079                }
10080        }
10081
10082        public final TbodyContext tbody() throws RecognitionException {
10083                TbodyContext _localctx = new TbodyContext(_ctx, getState());
10084                enterRule(_localctx, 88, RULE_tbody);
10085                try {
10086                        int _alt;
10087                        enterOuterAlt(_localctx, 1);
10088                        {
10089                        setState(1158);
10090                        tbodyTagOpen();
10091                        setState(1198);
10092                        _errHandler.sync(this);
10093                        _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10094                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10095                                if ( _alt==1 ) {
10096                                        {
10097                                        setState(1196);
10098                                        _errHandler.sync(this);
10099                                        switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
10100                                        case 1:
10101                                                {
10102                                                setState(1159);
10103                                                htmlTag();
10104                                                }
10105                                                break;
10106                                        case 2:
10107                                                {
10108                                                setState(1160);
10109                                                singletonTag();
10110                                                }
10111                                                break;
10112                                        case 3:
10113                                                {
10114                                                setState(1161);
10115                                                paragraph();
10116                                                }
10117                                                break;
10118                                        case 4:
10119                                                {
10120                                                setState(1162);
10121                                                li();
10122                                                }
10123                                                break;
10124                                        case 5:
10125                                                {
10126                                                setState(1163);
10127                                                tr();
10128                                                }
10129                                                break;
10130                                        case 6:
10131                                                {
10132                                                setState(1164);
10133                                                td();
10134                                                }
10135                                                break;
10136                                        case 7:
10137                                                {
10138                                                setState(1165);
10139                                                th();
10140                                                }
10141                                                break;
10142                                        case 8:
10143                                                {
10144                                                setState(1166);
10145                                                body();
10146                                                }
10147                                                break;
10148                                        case 9:
10149                                                {
10150                                                setState(1167);
10151                                                colgroup();
10152                                                }
10153                                                break;
10154                                        case 10:
10155                                                {
10156                                                setState(1168);
10157                                                dd();
10158                                                }
10159                                                break;
10160                                        case 11:
10161                                                {
10162                                                setState(1169);
10163                                                dt();
10164                                                }
10165                                                break;
10166                                        case 12:
10167                                                {
10168                                                setState(1170);
10169                                                head();
10170                                                }
10171                                                break;
10172                                        case 13:
10173                                                {
10174                                                setState(1171);
10175                                                html();
10176                                                }
10177                                                break;
10178                                        case 14:
10179                                                {
10180                                                setState(1172);
10181                                                option();
10182                                                }
10183                                                break;
10184                                        case 15:
10185                                                {
10186                                                setState(1173);
10187                                                thead();
10188                                                }
10189                                                break;
10190                                        case 16:
10191                                                {
10192                                                setState(1174);
10193                                                tfoot();
10194                                                }
10195                                                break;
10196                                        case 17:
10197                                                {
10198                                                setState(1175);
10199                                                pTagOpen();
10200                                                }
10201                                                break;
10202                                        case 18:
10203                                                {
10204                                                setState(1176);
10205                                                liTagOpen();
10206                                                }
10207                                                break;
10208                                        case 19:
10209                                                {
10210                                                setState(1177);
10211                                                trTagOpen();
10212                                                }
10213                                                break;
10214                                        case 20:
10215                                                {
10216                                                setState(1178);
10217                                                tdTagOpen();
10218                                                }
10219                                                break;
10220                                        case 21:
10221                                                {
10222                                                setState(1179);
10223                                                thTagOpen();
10224                                                }
10225                                                break;
10226                                        case 22:
10227                                                {
10228                                                setState(1180);
10229                                                bodyTagOpen();
10230                                                }
10231                                                break;
10232                                        case 23:
10233                                                {
10234                                                setState(1181);
10235                                                colgroupTagOpen();
10236                                                }
10237                                                break;
10238                                        case 24:
10239                                                {
10240                                                setState(1182);
10241                                                ddTagOpen();
10242                                                }
10243                                                break;
10244                                        case 25:
10245                                                {
10246                                                setState(1183);
10247                                                dtTagOpen();
10248                                                }
10249                                                break;
10250                                        case 26:
10251                                                {
10252                                                setState(1184);
10253                                                headTagOpen();
10254                                                }
10255                                                break;
10256                                        case 27:
10257                                                {
10258                                                setState(1185);
10259                                                htmlTagOpen();
10260                                                }
10261                                                break;
10262                                        case 28:
10263                                                {
10264                                                setState(1186);
10265                                                optionTagOpen();
10266                                                }
10267                                                break;
10268                                        case 29:
10269                                                {
10270                                                setState(1187);
10271                                                theadTagOpen();
10272                                                }
10273                                                break;
10274                                        case 30:
10275                                                {
10276                                                setState(1188);
10277                                                tfootTagOpen();
10278                                                }
10279                                                break;
10280                                        case 31:
10281                                                {
10282                                                {
10283                                                setState(1189);
10284                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10285                                                setState(1190);
10286                                                match(LEADING_ASTERISK);
10287                                                }
10288                                                }
10289                                                break;
10290                                        case 32:
10291                                                {
10292                                                setState(1191);
10293                                                htmlComment();
10294                                                }
10295                                                break;
10296                                        case 33:
10297                                                {
10298                                                setState(1192);
10299                                                match(CDATA);
10300                                                }
10301                                                break;
10302                                        case 34:
10303                                                {
10304                                                setState(1193);
10305                                                match(NEWLINE);
10306                                                }
10307                                                break;
10308                                        case 35:
10309                                                {
10310                                                setState(1194);
10311                                                text();
10312                                                }
10313                                                break;
10314                                        case 36:
10315                                                {
10316                                                setState(1195);
10317                                                javadocInlineTag();
10318                                                }
10319                                                break;
10320                                        }
10321                                        } 
10322                                }
10323                                setState(1200);
10324                                _errHandler.sync(this);
10325                                _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10326                        }
10327                        setState(1201);
10328                        tbodyTagClose();
10329                        }
10330                }
10331                catch (RecognitionException re) {
10332                        _localctx.exception = re;
10333                        _errHandler.reportError(this, re);
10334                        _errHandler.recover(this, re);
10335                }
10336                finally {
10337                        exitRule();
10338                }
10339                return _localctx;
10340        }
10341
10342        public static class TfootTagOpenContext extends ParserRuleContext {
10343                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10344                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10345                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10346                public List<AttributeContext> attribute() {
10347                        return getRuleContexts(AttributeContext.class);
10348                }
10349                public AttributeContext attribute(int i) {
10350                        return getRuleContext(AttributeContext.class,i);
10351                }
10352                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10353                public TerminalNode NEWLINE(int i) {
10354                        return getToken(JavadocParser.NEWLINE, i);
10355                }
10356                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10357                public TerminalNode LEADING_ASTERISK(int i) {
10358                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10359                }
10360                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10361                public TerminalNode WS(int i) {
10362                        return getToken(JavadocParser.WS, i);
10363                }
10364                public TfootTagOpenContext(ParserRuleContext parent, int invokingState) {
10365                        super(parent, invokingState);
10366                }
10367                @Override public int getRuleIndex() { return RULE_tfootTagOpen; }
10368                @Override
10369                public void enterRule(ParseTreeListener listener) {
10370                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this);
10371                }
10372                @Override
10373                public void exitRule(ParseTreeListener listener) {
10374                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this);
10375                }
10376                @Override
10377                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10378                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this);
10379                        else return visitor.visitChildren(this);
10380                }
10381        }
10382
10383        public final TfootTagOpenContext tfootTagOpen() throws RecognitionException {
10384                TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState());
10385                enterRule(_localctx, 90, RULE_tfootTagOpen);
10386                int _la;
10387                try {
10388                        enterOuterAlt(_localctx, 1);
10389                        {
10390                        setState(1203);
10391                        match(OPEN);
10392                        setState(1204);
10393                        match(TFOOT_HTML_TAG_NAME);
10394                        setState(1211);
10395                        _errHandler.sync(this);
10396                        _la = _input.LA(1);
10397                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10398                                {
10399                                setState(1209);
10400                                switch (_input.LA(1)) {
10401                                case HTML_TAG_NAME:
10402                                        {
10403                                        setState(1205);
10404                                        attribute();
10405                                        }
10406                                        break;
10407                                case NEWLINE:
10408                                        {
10409                                        setState(1206);
10410                                        match(NEWLINE);
10411                                        }
10412                                        break;
10413                                case LEADING_ASTERISK:
10414                                        {
10415                                        setState(1207);
10416                                        match(LEADING_ASTERISK);
10417                                        }
10418                                        break;
10419                                case WS:
10420                                        {
10421                                        setState(1208);
10422                                        match(WS);
10423                                        }
10424                                        break;
10425                                default:
10426                                        throw new NoViableAltException(this);
10427                                }
10428                                }
10429                                setState(1213);
10430                                _errHandler.sync(this);
10431                                _la = _input.LA(1);
10432                        }
10433                        setState(1214);
10434                        match(CLOSE);
10435                        }
10436                }
10437                catch (RecognitionException re) {
10438                        _localctx.exception = re;
10439                        _errHandler.reportError(this, re);
10440                        _errHandler.recover(this, re);
10441                }
10442                finally {
10443                        exitRule();
10444                }
10445                return _localctx;
10446        }
10447
10448        public static class TfootTagCloseContext extends ParserRuleContext {
10449                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10450                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10451                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10452                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10453                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10454                public TerminalNode NEWLINE(int i) {
10455                        return getToken(JavadocParser.NEWLINE, i);
10456                }
10457                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10458                public TerminalNode LEADING_ASTERISK(int i) {
10459                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10460                }
10461                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10462                public TerminalNode WS(int i) {
10463                        return getToken(JavadocParser.WS, i);
10464                }
10465                public TfootTagCloseContext(ParserRuleContext parent, int invokingState) {
10466                        super(parent, invokingState);
10467                }
10468                @Override public int getRuleIndex() { return RULE_tfootTagClose; }
10469                @Override
10470                public void enterRule(ParseTreeListener listener) {
10471                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this);
10472                }
10473                @Override
10474                public void exitRule(ParseTreeListener listener) {
10475                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this);
10476                }
10477                @Override
10478                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10479                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this);
10480                        else return visitor.visitChildren(this);
10481                }
10482        }
10483
10484        public final TfootTagCloseContext tfootTagClose() throws RecognitionException {
10485                TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState());
10486                enterRule(_localctx, 92, RULE_tfootTagClose);
10487                int _la;
10488                try {
10489                        enterOuterAlt(_localctx, 1);
10490                        {
10491                        setState(1216);
10492                        match(OPEN);
10493                        setState(1217);
10494                        match(SLASH);
10495                        setState(1218);
10496                        match(TFOOT_HTML_TAG_NAME);
10497                        setState(1222);
10498                        _errHandler.sync(this);
10499                        _la = _input.LA(1);
10500                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10501                                {
10502                                {
10503                                setState(1219);
10504                                _la = _input.LA(1);
10505                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10506                                _errHandler.recoverInline(this);
10507                                } else {
10508                                        consume();
10509                                }
10510                                }
10511                                }
10512                                setState(1224);
10513                                _errHandler.sync(this);
10514                                _la = _input.LA(1);
10515                        }
10516                        setState(1225);
10517                        match(CLOSE);
10518                        }
10519                }
10520                catch (RecognitionException re) {
10521                        _localctx.exception = re;
10522                        _errHandler.reportError(this, re);
10523                        _errHandler.recover(this, re);
10524                }
10525                finally {
10526                        exitRule();
10527                }
10528                return _localctx;
10529        }
10530
10531        public static class TfootContext extends ParserRuleContext {
10532                public TfootTagOpenContext tfootTagOpen() {
10533                        return getRuleContext(TfootTagOpenContext.class,0);
10534                }
10535                public TfootTagCloseContext tfootTagClose() {
10536                        return getRuleContext(TfootTagCloseContext.class,0);
10537                }
10538                public List<HtmlTagContext> htmlTag() {
10539                        return getRuleContexts(HtmlTagContext.class);
10540                }
10541                public HtmlTagContext htmlTag(int i) {
10542                        return getRuleContext(HtmlTagContext.class,i);
10543                }
10544                public List<SingletonTagContext> singletonTag() {
10545                        return getRuleContexts(SingletonTagContext.class);
10546                }
10547                public SingletonTagContext singletonTag(int i) {
10548                        return getRuleContext(SingletonTagContext.class,i);
10549                }
10550                public List<ParagraphContext> paragraph() {
10551                        return getRuleContexts(ParagraphContext.class);
10552                }
10553                public ParagraphContext paragraph(int i) {
10554                        return getRuleContext(ParagraphContext.class,i);
10555                }
10556                public List<LiContext> li() {
10557                        return getRuleContexts(LiContext.class);
10558                }
10559                public LiContext li(int i) {
10560                        return getRuleContext(LiContext.class,i);
10561                }
10562                public List<TrContext> tr() {
10563                        return getRuleContexts(TrContext.class);
10564                }
10565                public TrContext tr(int i) {
10566                        return getRuleContext(TrContext.class,i);
10567                }
10568                public List<TdContext> td() {
10569                        return getRuleContexts(TdContext.class);
10570                }
10571                public TdContext td(int i) {
10572                        return getRuleContext(TdContext.class,i);
10573                }
10574                public List<ThContext> th() {
10575                        return getRuleContexts(ThContext.class);
10576                }
10577                public ThContext th(int i) {
10578                        return getRuleContext(ThContext.class,i);
10579                }
10580                public List<BodyContext> body() {
10581                        return getRuleContexts(BodyContext.class);
10582                }
10583                public BodyContext body(int i) {
10584                        return getRuleContext(BodyContext.class,i);
10585                }
10586                public List<ColgroupContext> colgroup() {
10587                        return getRuleContexts(ColgroupContext.class);
10588                }
10589                public ColgroupContext colgroup(int i) {
10590                        return getRuleContext(ColgroupContext.class,i);
10591                }
10592                public List<DdContext> dd() {
10593                        return getRuleContexts(DdContext.class);
10594                }
10595                public DdContext dd(int i) {
10596                        return getRuleContext(DdContext.class,i);
10597                }
10598                public List<DtContext> dt() {
10599                        return getRuleContexts(DtContext.class);
10600                }
10601                public DtContext dt(int i) {
10602                        return getRuleContext(DtContext.class,i);
10603                }
10604                public List<HeadContext> head() {
10605                        return getRuleContexts(HeadContext.class);
10606                }
10607                public HeadContext head(int i) {
10608                        return getRuleContext(HeadContext.class,i);
10609                }
10610                public List<HtmlContext> html() {
10611                        return getRuleContexts(HtmlContext.class);
10612                }
10613                public HtmlContext html(int i) {
10614                        return getRuleContext(HtmlContext.class,i);
10615                }
10616                public List<OptionContext> option() {
10617                        return getRuleContexts(OptionContext.class);
10618                }
10619                public OptionContext option(int i) {
10620                        return getRuleContext(OptionContext.class,i);
10621                }
10622                public List<TbodyContext> tbody() {
10623                        return getRuleContexts(TbodyContext.class);
10624                }
10625                public TbodyContext tbody(int i) {
10626                        return getRuleContext(TbodyContext.class,i);
10627                }
10628                public List<TheadContext> thead() {
10629                        return getRuleContexts(TheadContext.class);
10630                }
10631                public TheadContext thead(int i) {
10632                        return getRuleContext(TheadContext.class,i);
10633                }
10634                public List<PTagOpenContext> pTagOpen() {
10635                        return getRuleContexts(PTagOpenContext.class);
10636                }
10637                public PTagOpenContext pTagOpen(int i) {
10638                        return getRuleContext(PTagOpenContext.class,i);
10639                }
10640                public List<LiTagOpenContext> liTagOpen() {
10641                        return getRuleContexts(LiTagOpenContext.class);
10642                }
10643                public LiTagOpenContext liTagOpen(int i) {
10644                        return getRuleContext(LiTagOpenContext.class,i);
10645                }
10646                public List<TrTagOpenContext> trTagOpen() {
10647                        return getRuleContexts(TrTagOpenContext.class);
10648                }
10649                public TrTagOpenContext trTagOpen(int i) {
10650                        return getRuleContext(TrTagOpenContext.class,i);
10651                }
10652                public List<TdTagOpenContext> tdTagOpen() {
10653                        return getRuleContexts(TdTagOpenContext.class);
10654                }
10655                public TdTagOpenContext tdTagOpen(int i) {
10656                        return getRuleContext(TdTagOpenContext.class,i);
10657                }
10658                public List<ThTagOpenContext> thTagOpen() {
10659                        return getRuleContexts(ThTagOpenContext.class);
10660                }
10661                public ThTagOpenContext thTagOpen(int i) {
10662                        return getRuleContext(ThTagOpenContext.class,i);
10663                }
10664                public List<BodyTagOpenContext> bodyTagOpen() {
10665                        return getRuleContexts(BodyTagOpenContext.class);
10666                }
10667                public BodyTagOpenContext bodyTagOpen(int i) {
10668                        return getRuleContext(BodyTagOpenContext.class,i);
10669                }
10670                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10671                        return getRuleContexts(ColgroupTagOpenContext.class);
10672                }
10673                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10674                        return getRuleContext(ColgroupTagOpenContext.class,i);
10675                }
10676                public List<DdTagOpenContext> ddTagOpen() {
10677                        return getRuleContexts(DdTagOpenContext.class);
10678                }
10679                public DdTagOpenContext ddTagOpen(int i) {
10680                        return getRuleContext(DdTagOpenContext.class,i);
10681                }
10682                public List<DtTagOpenContext> dtTagOpen() {
10683                        return getRuleContexts(DtTagOpenContext.class);
10684                }
10685                public DtTagOpenContext dtTagOpen(int i) {
10686                        return getRuleContext(DtTagOpenContext.class,i);
10687                }
10688                public List<HeadTagOpenContext> headTagOpen() {
10689                        return getRuleContexts(HeadTagOpenContext.class);
10690                }
10691                public HeadTagOpenContext headTagOpen(int i) {
10692                        return getRuleContext(HeadTagOpenContext.class,i);
10693                }
10694                public List<HtmlTagOpenContext> htmlTagOpen() {
10695                        return getRuleContexts(HtmlTagOpenContext.class);
10696                }
10697                public HtmlTagOpenContext htmlTagOpen(int i) {
10698                        return getRuleContext(HtmlTagOpenContext.class,i);
10699                }
10700                public List<OptionTagOpenContext> optionTagOpen() {
10701                        return getRuleContexts(OptionTagOpenContext.class);
10702                }
10703                public OptionTagOpenContext optionTagOpen(int i) {
10704                        return getRuleContext(OptionTagOpenContext.class,i);
10705                }
10706                public List<TbodyTagOpenContext> tbodyTagOpen() {
10707                        return getRuleContexts(TbodyTagOpenContext.class);
10708                }
10709                public TbodyTagOpenContext tbodyTagOpen(int i) {
10710                        return getRuleContext(TbodyTagOpenContext.class,i);
10711                }
10712                public List<TheadTagOpenContext> theadTagOpen() {
10713                        return getRuleContexts(TheadTagOpenContext.class);
10714                }
10715                public TheadTagOpenContext theadTagOpen(int i) {
10716                        return getRuleContext(TheadTagOpenContext.class,i);
10717                }
10718                public List<HtmlCommentContext> htmlComment() {
10719                        return getRuleContexts(HtmlCommentContext.class);
10720                }
10721                public HtmlCommentContext htmlComment(int i) {
10722                        return getRuleContext(HtmlCommentContext.class,i);
10723                }
10724                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10725                public TerminalNode CDATA(int i) {
10726                        return getToken(JavadocParser.CDATA, i);
10727                }
10728                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10729                public TerminalNode NEWLINE(int i) {
10730                        return getToken(JavadocParser.NEWLINE, i);
10731                }
10732                public List<TextContext> text() {
10733                        return getRuleContexts(TextContext.class);
10734                }
10735                public TextContext text(int i) {
10736                        return getRuleContext(TextContext.class,i);
10737                }
10738                public List<JavadocInlineTagContext> javadocInlineTag() {
10739                        return getRuleContexts(JavadocInlineTagContext.class);
10740                }
10741                public JavadocInlineTagContext javadocInlineTag(int i) {
10742                        return getRuleContext(JavadocInlineTagContext.class,i);
10743                }
10744                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10745                public TerminalNode LEADING_ASTERISK(int i) {
10746                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10747                }
10748                public TfootContext(ParserRuleContext parent, int invokingState) {
10749                        super(parent, invokingState);
10750                }
10751                @Override public int getRuleIndex() { return RULE_tfoot; }
10752                @Override
10753                public void enterRule(ParseTreeListener listener) {
10754                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this);
10755                }
10756                @Override
10757                public void exitRule(ParseTreeListener listener) {
10758                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this);
10759                }
10760                @Override
10761                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10762                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this);
10763                        else return visitor.visitChildren(this);
10764                }
10765        }
10766
10767        public final TfootContext tfoot() throws RecognitionException {
10768                TfootContext _localctx = new TfootContext(_ctx, getState());
10769                enterRule(_localctx, 94, RULE_tfoot);
10770                try {
10771                        int _alt;
10772                        enterOuterAlt(_localctx, 1);
10773                        {
10774                        setState(1227);
10775                        tfootTagOpen();
10776                        setState(1267);
10777                        _errHandler.sync(this);
10778                        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10779                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10780                                if ( _alt==1 ) {
10781                                        {
10782                                        setState(1265);
10783                                        _errHandler.sync(this);
10784                                        switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
10785                                        case 1:
10786                                                {
10787                                                setState(1228);
10788                                                htmlTag();
10789                                                }
10790                                                break;
10791                                        case 2:
10792                                                {
10793                                                setState(1229);
10794                                                singletonTag();
10795                                                }
10796                                                break;
10797                                        case 3:
10798                                                {
10799                                                setState(1230);
10800                                                paragraph();
10801                                                }
10802                                                break;
10803                                        case 4:
10804                                                {
10805                                                setState(1231);
10806                                                li();
10807                                                }
10808                                                break;
10809                                        case 5:
10810                                                {
10811                                                setState(1232);
10812                                                tr();
10813                                                }
10814                                                break;
10815                                        case 6:
10816                                                {
10817                                                setState(1233);
10818                                                td();
10819                                                }
10820                                                break;
10821                                        case 7:
10822                                                {
10823                                                setState(1234);
10824                                                th();
10825                                                }
10826                                                break;
10827                                        case 8:
10828                                                {
10829                                                setState(1235);
10830                                                body();
10831                                                }
10832                                                break;
10833                                        case 9:
10834                                                {
10835                                                setState(1236);
10836                                                colgroup();
10837                                                }
10838                                                break;
10839                                        case 10:
10840                                                {
10841                                                setState(1237);
10842                                                dd();
10843                                                }
10844                                                break;
10845                                        case 11:
10846                                                {
10847                                                setState(1238);
10848                                                dt();
10849                                                }
10850                                                break;
10851                                        case 12:
10852                                                {
10853                                                setState(1239);
10854                                                head();
10855                                                }
10856                                                break;
10857                                        case 13:
10858                                                {
10859                                                setState(1240);
10860                                                html();
10861                                                }
10862                                                break;
10863                                        case 14:
10864                                                {
10865                                                setState(1241);
10866                                                option();
10867                                                }
10868                                                break;
10869                                        case 15:
10870                                                {
10871                                                setState(1242);
10872                                                tbody();
10873                                                }
10874                                                break;
10875                                        case 16:
10876                                                {
10877                                                setState(1243);
10878                                                thead();
10879                                                }
10880                                                break;
10881                                        case 17:
10882                                                {
10883                                                setState(1244);
10884                                                pTagOpen();
10885                                                }
10886                                                break;
10887                                        case 18:
10888                                                {
10889                                                setState(1245);
10890                                                liTagOpen();
10891                                                }
10892                                                break;
10893                                        case 19:
10894                                                {
10895                                                setState(1246);
10896                                                trTagOpen();
10897                                                }
10898                                                break;
10899                                        case 20:
10900                                                {
10901                                                setState(1247);
10902                                                tdTagOpen();
10903                                                }
10904                                                break;
10905                                        case 21:
10906                                                {
10907                                                setState(1248);
10908                                                thTagOpen();
10909                                                }
10910                                                break;
10911                                        case 22:
10912                                                {
10913                                                setState(1249);
10914                                                bodyTagOpen();
10915                                                }
10916                                                break;
10917                                        case 23:
10918                                                {
10919                                                setState(1250);
10920                                                colgroupTagOpen();
10921                                                }
10922                                                break;
10923                                        case 24:
10924                                                {
10925                                                setState(1251);
10926                                                ddTagOpen();
10927                                                }
10928                                                break;
10929                                        case 25:
10930                                                {
10931                                                setState(1252);
10932                                                dtTagOpen();
10933                                                }
10934                                                break;
10935                                        case 26:
10936                                                {
10937                                                setState(1253);
10938                                                headTagOpen();
10939                                                }
10940                                                break;
10941                                        case 27:
10942                                                {
10943                                                setState(1254);
10944                                                htmlTagOpen();
10945                                                }
10946                                                break;
10947                                        case 28:
10948                                                {
10949                                                setState(1255);
10950                                                optionTagOpen();
10951                                                }
10952                                                break;
10953                                        case 29:
10954                                                {
10955                                                setState(1256);
10956                                                tbodyTagOpen();
10957                                                }
10958                                                break;
10959                                        case 30:
10960                                                {
10961                                                setState(1257);
10962                                                theadTagOpen();
10963                                                }
10964                                                break;
10965                                        case 31:
10966                                                {
10967                                                {
10968                                                setState(1258);
10969                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10970                                                setState(1259);
10971                                                match(LEADING_ASTERISK);
10972                                                }
10973                                                }
10974                                                break;
10975                                        case 32:
10976                                                {
10977                                                setState(1260);
10978                                                htmlComment();
10979                                                }
10980                                                break;
10981                                        case 33:
10982                                                {
10983                                                setState(1261);
10984                                                match(CDATA);
10985                                                }
10986                                                break;
10987                                        case 34:
10988                                                {
10989                                                setState(1262);
10990                                                match(NEWLINE);
10991                                                }
10992                                                break;
10993                                        case 35:
10994                                                {
10995                                                setState(1263);
10996                                                text();
10997                                                }
10998                                                break;
10999                                        case 36:
11000                                                {
11001                                                setState(1264);
11002                                                javadocInlineTag();
11003                                                }
11004                                                break;
11005                                        }
11006                                        } 
11007                                }
11008                                setState(1269);
11009                                _errHandler.sync(this);
11010                                _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
11011                        }
11012                        setState(1270);
11013                        tfootTagClose();
11014                        }
11015                }
11016                catch (RecognitionException re) {
11017                        _localctx.exception = re;
11018                        _errHandler.reportError(this, re);
11019                        _errHandler.recover(this, re);
11020                }
11021                finally {
11022                        exitRule();
11023                }
11024                return _localctx;
11025        }
11026
11027        public static class TheadTagOpenContext extends ParserRuleContext {
11028                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11029                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11030                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11031                public List<AttributeContext> attribute() {
11032                        return getRuleContexts(AttributeContext.class);
11033                }
11034                public AttributeContext attribute(int i) {
11035                        return getRuleContext(AttributeContext.class,i);
11036                }
11037                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11038                public TerminalNode NEWLINE(int i) {
11039                        return getToken(JavadocParser.NEWLINE, i);
11040                }
11041                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11042                public TerminalNode LEADING_ASTERISK(int i) {
11043                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11044                }
11045                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11046                public TerminalNode WS(int i) {
11047                        return getToken(JavadocParser.WS, i);
11048                }
11049                public TheadTagOpenContext(ParserRuleContext parent, int invokingState) {
11050                        super(parent, invokingState);
11051                }
11052                @Override public int getRuleIndex() { return RULE_theadTagOpen; }
11053                @Override
11054                public void enterRule(ParseTreeListener listener) {
11055                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this);
11056                }
11057                @Override
11058                public void exitRule(ParseTreeListener listener) {
11059                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this);
11060                }
11061                @Override
11062                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11063                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this);
11064                        else return visitor.visitChildren(this);
11065                }
11066        }
11067
11068        public final TheadTagOpenContext theadTagOpen() throws RecognitionException {
11069                TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState());
11070                enterRule(_localctx, 96, RULE_theadTagOpen);
11071                int _la;
11072                try {
11073                        enterOuterAlt(_localctx, 1);
11074                        {
11075                        setState(1272);
11076                        match(OPEN);
11077                        setState(1273);
11078                        match(THEAD_HTML_TAG_NAME);
11079                        setState(1280);
11080                        _errHandler.sync(this);
11081                        _la = _input.LA(1);
11082                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11083                                {
11084                                setState(1278);
11085                                switch (_input.LA(1)) {
11086                                case HTML_TAG_NAME:
11087                                        {
11088                                        setState(1274);
11089                                        attribute();
11090                                        }
11091                                        break;
11092                                case NEWLINE:
11093                                        {
11094                                        setState(1275);
11095                                        match(NEWLINE);
11096                                        }
11097                                        break;
11098                                case LEADING_ASTERISK:
11099                                        {
11100                                        setState(1276);
11101                                        match(LEADING_ASTERISK);
11102                                        }
11103                                        break;
11104                                case WS:
11105                                        {
11106                                        setState(1277);
11107                                        match(WS);
11108                                        }
11109                                        break;
11110                                default:
11111                                        throw new NoViableAltException(this);
11112                                }
11113                                }
11114                                setState(1282);
11115                                _errHandler.sync(this);
11116                                _la = _input.LA(1);
11117                        }
11118                        setState(1283);
11119                        match(CLOSE);
11120                        }
11121                }
11122                catch (RecognitionException re) {
11123                        _localctx.exception = re;
11124                        _errHandler.reportError(this, re);
11125                        _errHandler.recover(this, re);
11126                }
11127                finally {
11128                        exitRule();
11129                }
11130                return _localctx;
11131        }
11132
11133        public static class TheadTagCloseContext extends ParserRuleContext {
11134                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11135                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
11136                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11137                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11138                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11139                public TerminalNode NEWLINE(int i) {
11140                        return getToken(JavadocParser.NEWLINE, i);
11141                }
11142                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11143                public TerminalNode LEADING_ASTERISK(int i) {
11144                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11145                }
11146                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11147                public TerminalNode WS(int i) {
11148                        return getToken(JavadocParser.WS, i);
11149                }
11150                public TheadTagCloseContext(ParserRuleContext parent, int invokingState) {
11151                        super(parent, invokingState);
11152                }
11153                @Override public int getRuleIndex() { return RULE_theadTagClose; }
11154                @Override
11155                public void enterRule(ParseTreeListener listener) {
11156                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this);
11157                }
11158                @Override
11159                public void exitRule(ParseTreeListener listener) {
11160                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this);
11161                }
11162                @Override
11163                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11164                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this);
11165                        else return visitor.visitChildren(this);
11166                }
11167        }
11168
11169        public final TheadTagCloseContext theadTagClose() throws RecognitionException {
11170                TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState());
11171                enterRule(_localctx, 98, RULE_theadTagClose);
11172                int _la;
11173                try {
11174                        enterOuterAlt(_localctx, 1);
11175                        {
11176                        setState(1285);
11177                        match(OPEN);
11178                        setState(1286);
11179                        match(SLASH);
11180                        setState(1287);
11181                        match(THEAD_HTML_TAG_NAME);
11182                        setState(1291);
11183                        _errHandler.sync(this);
11184                        _la = _input.LA(1);
11185                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
11186                                {
11187                                {
11188                                setState(1288);
11189                                _la = _input.LA(1);
11190                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
11191                                _errHandler.recoverInline(this);
11192                                } else {
11193                                        consume();
11194                                }
11195                                }
11196                                }
11197                                setState(1293);
11198                                _errHandler.sync(this);
11199                                _la = _input.LA(1);
11200                        }
11201                        setState(1294);
11202                        match(CLOSE);
11203                        }
11204                }
11205                catch (RecognitionException re) {
11206                        _localctx.exception = re;
11207                        _errHandler.reportError(this, re);
11208                        _errHandler.recover(this, re);
11209                }
11210                finally {
11211                        exitRule();
11212                }
11213                return _localctx;
11214        }
11215
11216        public static class TheadContext extends ParserRuleContext {
11217                public TheadTagOpenContext theadTagOpen() {
11218                        return getRuleContext(TheadTagOpenContext.class,0);
11219                }
11220                public TheadTagCloseContext theadTagClose() {
11221                        return getRuleContext(TheadTagCloseContext.class,0);
11222                }
11223                public List<HtmlTagContext> htmlTag() {
11224                        return getRuleContexts(HtmlTagContext.class);
11225                }
11226                public HtmlTagContext htmlTag(int i) {
11227                        return getRuleContext(HtmlTagContext.class,i);
11228                }
11229                public List<SingletonTagContext> singletonTag() {
11230                        return getRuleContexts(SingletonTagContext.class);
11231                }
11232                public SingletonTagContext singletonTag(int i) {
11233                        return getRuleContext(SingletonTagContext.class,i);
11234                }
11235                public List<ParagraphContext> paragraph() {
11236                        return getRuleContexts(ParagraphContext.class);
11237                }
11238                public ParagraphContext paragraph(int i) {
11239                        return getRuleContext(ParagraphContext.class,i);
11240                }
11241                public List<LiContext> li() {
11242                        return getRuleContexts(LiContext.class);
11243                }
11244                public LiContext li(int i) {
11245                        return getRuleContext(LiContext.class,i);
11246                }
11247                public List<TrContext> tr() {
11248                        return getRuleContexts(TrContext.class);
11249                }
11250                public TrContext tr(int i) {
11251                        return getRuleContext(TrContext.class,i);
11252                }
11253                public List<TdContext> td() {
11254                        return getRuleContexts(TdContext.class);
11255                }
11256                public TdContext td(int i) {
11257                        return getRuleContext(TdContext.class,i);
11258                }
11259                public List<ThContext> th() {
11260                        return getRuleContexts(ThContext.class);
11261                }
11262                public ThContext th(int i) {
11263                        return getRuleContext(ThContext.class,i);
11264                }
11265                public List<BodyContext> body() {
11266                        return getRuleContexts(BodyContext.class);
11267                }
11268                public BodyContext body(int i) {
11269                        return getRuleContext(BodyContext.class,i);
11270                }
11271                public List<ColgroupContext> colgroup() {
11272                        return getRuleContexts(ColgroupContext.class);
11273                }
11274                public ColgroupContext colgroup(int i) {
11275                        return getRuleContext(ColgroupContext.class,i);
11276                }
11277                public List<DdContext> dd() {
11278                        return getRuleContexts(DdContext.class);
11279                }
11280                public DdContext dd(int i) {
11281                        return getRuleContext(DdContext.class,i);
11282                }
11283                public List<DtContext> dt() {
11284                        return getRuleContexts(DtContext.class);
11285                }
11286                public DtContext dt(int i) {
11287                        return getRuleContext(DtContext.class,i);
11288                }
11289                public List<HeadContext> head() {
11290                        return getRuleContexts(HeadContext.class);
11291                }
11292                public HeadContext head(int i) {
11293                        return getRuleContext(HeadContext.class,i);
11294                }
11295                public List<HtmlContext> html() {
11296                        return getRuleContexts(HtmlContext.class);
11297                }
11298                public HtmlContext html(int i) {
11299                        return getRuleContext(HtmlContext.class,i);
11300                }
11301                public List<OptionContext> option() {
11302                        return getRuleContexts(OptionContext.class);
11303                }
11304                public OptionContext option(int i) {
11305                        return getRuleContext(OptionContext.class,i);
11306                }
11307                public List<TbodyContext> tbody() {
11308                        return getRuleContexts(TbodyContext.class);
11309                }
11310                public TbodyContext tbody(int i) {
11311                        return getRuleContext(TbodyContext.class,i);
11312                }
11313                public List<TfootContext> tfoot() {
11314                        return getRuleContexts(TfootContext.class);
11315                }
11316                public TfootContext tfoot(int i) {
11317                        return getRuleContext(TfootContext.class,i);
11318                }
11319                public List<PTagOpenContext> pTagOpen() {
11320                        return getRuleContexts(PTagOpenContext.class);
11321                }
11322                public PTagOpenContext pTagOpen(int i) {
11323                        return getRuleContext(PTagOpenContext.class,i);
11324                }
11325                public List<LiTagOpenContext> liTagOpen() {
11326                        return getRuleContexts(LiTagOpenContext.class);
11327                }
11328                public LiTagOpenContext liTagOpen(int i) {
11329                        return getRuleContext(LiTagOpenContext.class,i);
11330                }
11331                public List<TrTagOpenContext> trTagOpen() {
11332                        return getRuleContexts(TrTagOpenContext.class);
11333                }
11334                public TrTagOpenContext trTagOpen(int i) {
11335                        return getRuleContext(TrTagOpenContext.class,i);
11336                }
11337                public List<TdTagOpenContext> tdTagOpen() {
11338                        return getRuleContexts(TdTagOpenContext.class);
11339                }
11340                public TdTagOpenContext tdTagOpen(int i) {
11341                        return getRuleContext(TdTagOpenContext.class,i);
11342                }
11343                public List<ThTagOpenContext> thTagOpen() {
11344                        return getRuleContexts(ThTagOpenContext.class);
11345                }
11346                public ThTagOpenContext thTagOpen(int i) {
11347                        return getRuleContext(ThTagOpenContext.class,i);
11348                }
11349                public List<BodyTagOpenContext> bodyTagOpen() {
11350                        return getRuleContexts(BodyTagOpenContext.class);
11351                }
11352                public BodyTagOpenContext bodyTagOpen(int i) {
11353                        return getRuleContext(BodyTagOpenContext.class,i);
11354                }
11355                public List<ColgroupTagOpenContext> colgroupTagOpen() {
11356                        return getRuleContexts(ColgroupTagOpenContext.class);
11357                }
11358                public ColgroupTagOpenContext colgroupTagOpen(int i) {
11359                        return getRuleContext(ColgroupTagOpenContext.class,i);
11360                }
11361                public List<DdTagOpenContext> ddTagOpen() {
11362                        return getRuleContexts(DdTagOpenContext.class);
11363                }
11364                public DdTagOpenContext ddTagOpen(int i) {
11365                        return getRuleContext(DdTagOpenContext.class,i);
11366                }
11367                public List<DtTagOpenContext> dtTagOpen() {
11368                        return getRuleContexts(DtTagOpenContext.class);
11369                }
11370                public DtTagOpenContext dtTagOpen(int i) {
11371                        return getRuleContext(DtTagOpenContext.class,i);
11372                }
11373                public List<HeadTagOpenContext> headTagOpen() {
11374                        return getRuleContexts(HeadTagOpenContext.class);
11375                }
11376                public HeadTagOpenContext headTagOpen(int i) {
11377                        return getRuleContext(HeadTagOpenContext.class,i);
11378                }
11379                public List<HtmlTagOpenContext> htmlTagOpen() {
11380                        return getRuleContexts(HtmlTagOpenContext.class);
11381                }
11382                public HtmlTagOpenContext htmlTagOpen(int i) {
11383                        return getRuleContext(HtmlTagOpenContext.class,i);
11384                }
11385                public List<OptionTagOpenContext> optionTagOpen() {
11386                        return getRuleContexts(OptionTagOpenContext.class);
11387                }
11388                public OptionTagOpenContext optionTagOpen(int i) {
11389                        return getRuleContext(OptionTagOpenContext.class,i);
11390                }
11391                public List<TbodyTagOpenContext> tbodyTagOpen() {
11392                        return getRuleContexts(TbodyTagOpenContext.class);
11393                }
11394                public TbodyTagOpenContext tbodyTagOpen(int i) {
11395                        return getRuleContext(TbodyTagOpenContext.class,i);
11396                }
11397                public List<TfootTagOpenContext> tfootTagOpen() {
11398                        return getRuleContexts(TfootTagOpenContext.class);
11399                }
11400                public TfootTagOpenContext tfootTagOpen(int i) {
11401                        return getRuleContext(TfootTagOpenContext.class,i);
11402                }
11403                public List<HtmlCommentContext> htmlComment() {
11404                        return getRuleContexts(HtmlCommentContext.class);
11405                }
11406                public HtmlCommentContext htmlComment(int i) {
11407                        return getRuleContext(HtmlCommentContext.class,i);
11408                }
11409                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
11410                public TerminalNode CDATA(int i) {
11411                        return getToken(JavadocParser.CDATA, i);
11412                }
11413                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11414                public TerminalNode NEWLINE(int i) {
11415                        return getToken(JavadocParser.NEWLINE, i);
11416                }
11417                public List<TextContext> text() {
11418                        return getRuleContexts(TextContext.class);
11419                }
11420                public TextContext text(int i) {
11421                        return getRuleContext(TextContext.class,i);
11422                }
11423                public List<JavadocInlineTagContext> javadocInlineTag() {
11424                        return getRuleContexts(JavadocInlineTagContext.class);
11425                }
11426                public JavadocInlineTagContext javadocInlineTag(int i) {
11427                        return getRuleContext(JavadocInlineTagContext.class,i);
11428                }
11429                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11430                public TerminalNode LEADING_ASTERISK(int i) {
11431                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11432                }
11433                public TheadContext(ParserRuleContext parent, int invokingState) {
11434                        super(parent, invokingState);
11435                }
11436                @Override public int getRuleIndex() { return RULE_thead; }
11437                @Override
11438                public void enterRule(ParseTreeListener listener) {
11439                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this);
11440                }
11441                @Override
11442                public void exitRule(ParseTreeListener listener) {
11443                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this);
11444                }
11445                @Override
11446                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11447                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this);
11448                        else return visitor.visitChildren(this);
11449                }
11450        }
11451
11452        public final TheadContext thead() throws RecognitionException {
11453                TheadContext _localctx = new TheadContext(_ctx, getState());
11454                enterRule(_localctx, 100, RULE_thead);
11455                try {
11456                        int _alt;
11457                        enterOuterAlt(_localctx, 1);
11458                        {
11459                        setState(1296);
11460                        theadTagOpen();
11461                        setState(1336);
11462                        _errHandler.sync(this);
11463                        _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11464                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11465                                if ( _alt==1 ) {
11466                                        {
11467                                        setState(1334);
11468                                        _errHandler.sync(this);
11469                                        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
11470                                        case 1:
11471                                                {
11472                                                setState(1297);
11473                                                htmlTag();
11474                                                }
11475                                                break;
11476                                        case 2:
11477                                                {
11478                                                setState(1298);
11479                                                singletonTag();
11480                                                }
11481                                                break;
11482                                        case 3:
11483                                                {
11484                                                setState(1299);
11485                                                paragraph();
11486                                                }
11487                                                break;
11488                                        case 4:
11489                                                {
11490                                                setState(1300);
11491                                                li();
11492                                                }
11493                                                break;
11494                                        case 5:
11495                                                {
11496                                                setState(1301);
11497                                                tr();
11498                                                }
11499                                                break;
11500                                        case 6:
11501                                                {
11502                                                setState(1302);
11503                                                td();
11504                                                }
11505                                                break;
11506                                        case 7:
11507                                                {
11508                                                setState(1303);
11509                                                th();
11510                                                }
11511                                                break;
11512                                        case 8:
11513                                                {
11514                                                setState(1304);
11515                                                body();
11516                                                }
11517                                                break;
11518                                        case 9:
11519                                                {
11520                                                setState(1305);
11521                                                colgroup();
11522                                                }
11523                                                break;
11524                                        case 10:
11525                                                {
11526                                                setState(1306);
11527                                                dd();
11528                                                }
11529                                                break;
11530                                        case 11:
11531                                                {
11532                                                setState(1307);
11533                                                dt();
11534                                                }
11535                                                break;
11536                                        case 12:
11537                                                {
11538                                                setState(1308);
11539                                                head();
11540                                                }
11541                                                break;
11542                                        case 13:
11543                                                {
11544                                                setState(1309);
11545                                                html();
11546                                                }
11547                                                break;
11548                                        case 14:
11549                                                {
11550                                                setState(1310);
11551                                                option();
11552                                                }
11553                                                break;
11554                                        case 15:
11555                                                {
11556                                                setState(1311);
11557                                                tbody();
11558                                                }
11559                                                break;
11560                                        case 16:
11561                                                {
11562                                                setState(1312);
11563                                                tfoot();
11564                                                }
11565                                                break;
11566                                        case 17:
11567                                                {
11568                                                setState(1313);
11569                                                pTagOpen();
11570                                                }
11571                                                break;
11572                                        case 18:
11573                                                {
11574                                                setState(1314);
11575                                                liTagOpen();
11576                                                }
11577                                                break;
11578                                        case 19:
11579                                                {
11580                                                setState(1315);
11581                                                trTagOpen();
11582                                                }
11583                                                break;
11584                                        case 20:
11585                                                {
11586                                                setState(1316);
11587                                                tdTagOpen();
11588                                                }
11589                                                break;
11590                                        case 21:
11591                                                {
11592                                                setState(1317);
11593                                                thTagOpen();
11594                                                }
11595                                                break;
11596                                        case 22:
11597                                                {
11598                                                setState(1318);
11599                                                bodyTagOpen();
11600                                                }
11601                                                break;
11602                                        case 23:
11603                                                {
11604                                                setState(1319);
11605                                                colgroupTagOpen();
11606                                                }
11607                                                break;
11608                                        case 24:
11609                                                {
11610                                                setState(1320);
11611                                                ddTagOpen();
11612                                                }
11613                                                break;
11614                                        case 25:
11615                                                {
11616                                                setState(1321);
11617                                                dtTagOpen();
11618                                                }
11619                                                break;
11620                                        case 26:
11621                                                {
11622                                                setState(1322);
11623                                                headTagOpen();
11624                                                }
11625                                                break;
11626                                        case 27:
11627                                                {
11628                                                setState(1323);
11629                                                htmlTagOpen();
11630                                                }
11631                                                break;
11632                                        case 28:
11633                                                {
11634                                                setState(1324);
11635                                                optionTagOpen();
11636                                                }
11637                                                break;
11638                                        case 29:
11639                                                {
11640                                                setState(1325);
11641                                                tbodyTagOpen();
11642                                                }
11643                                                break;
11644                                        case 30:
11645                                                {
11646                                                setState(1326);
11647                                                tfootTagOpen();
11648                                                }
11649                                                break;
11650                                        case 31:
11651                                                {
11652                                                {
11653                                                setState(1327);
11654                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11655                                                setState(1328);
11656                                                match(LEADING_ASTERISK);
11657                                                }
11658                                                }
11659                                                break;
11660                                        case 32:
11661                                                {
11662                                                setState(1329);
11663                                                htmlComment();
11664                                                }
11665                                                break;
11666                                        case 33:
11667                                                {
11668                                                setState(1330);
11669                                                match(CDATA);
11670                                                }
11671                                                break;
11672                                        case 34:
11673                                                {
11674                                                setState(1331);
11675                                                match(NEWLINE);
11676                                                }
11677                                                break;
11678                                        case 35:
11679                                                {
11680                                                setState(1332);
11681                                                text();
11682                                                }
11683                                                break;
11684                                        case 36:
11685                                                {
11686                                                setState(1333);
11687                                                javadocInlineTag();
11688                                                }
11689                                                break;
11690                                        }
11691                                        } 
11692                                }
11693                                setState(1338);
11694                                _errHandler.sync(this);
11695                                _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11696                        }
11697                        setState(1339);
11698                        theadTagClose();
11699                        }
11700                }
11701                catch (RecognitionException re) {
11702                        _localctx.exception = re;
11703                        _errHandler.reportError(this, re);
11704                        _errHandler.recover(this, re);
11705                }
11706                finally {
11707                        exitRule();
11708                }
11709                return _localctx;
11710        }
11711
11712        public static class SingletonElementContext extends ParserRuleContext {
11713                public SingletonTagContext singletonTag() {
11714                        return getRuleContext(SingletonTagContext.class,0);
11715                }
11716                public AreaTagContext areaTag() {
11717                        return getRuleContext(AreaTagContext.class,0);
11718                }
11719                public BaseTagContext baseTag() {
11720                        return getRuleContext(BaseTagContext.class,0);
11721                }
11722                public BasefontTagContext basefontTag() {
11723                        return getRuleContext(BasefontTagContext.class,0);
11724                }
11725                public BrTagContext brTag() {
11726                        return getRuleContext(BrTagContext.class,0);
11727                }
11728                public ColTagContext colTag() {
11729                        return getRuleContext(ColTagContext.class,0);
11730                }
11731                public FrameTagContext frameTag() {
11732                        return getRuleContext(FrameTagContext.class,0);
11733                }
11734                public HrTagContext hrTag() {
11735                        return getRuleContext(HrTagContext.class,0);
11736                }
11737                public ImgTagContext imgTag() {
11738                        return getRuleContext(ImgTagContext.class,0);
11739                }
11740                public InputTagContext inputTag() {
11741                        return getRuleContext(InputTagContext.class,0);
11742                }
11743                public IsindexTagContext isindexTag() {
11744                        return getRuleContext(IsindexTagContext.class,0);
11745                }
11746                public LinkTagContext linkTag() {
11747                        return getRuleContext(LinkTagContext.class,0);
11748                }
11749                public MetaTagContext metaTag() {
11750                        return getRuleContext(MetaTagContext.class,0);
11751                }
11752                public ParamTagContext paramTag() {
11753                        return getRuleContext(ParamTagContext.class,0);
11754                }
11755                public WrongSinletonTagContext wrongSinletonTag() {
11756                        return getRuleContext(WrongSinletonTagContext.class,0);
11757                }
11758                public SingletonElementContext(ParserRuleContext parent, int invokingState) {
11759                        super(parent, invokingState);
11760                }
11761                @Override public int getRuleIndex() { return RULE_singletonElement; }
11762                @Override
11763                public void enterRule(ParseTreeListener listener) {
11764                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this);
11765                }
11766                @Override
11767                public void exitRule(ParseTreeListener listener) {
11768                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this);
11769                }
11770                @Override
11771                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11772                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this);
11773                        else return visitor.visitChildren(this);
11774                }
11775        }
11776
11777        public final SingletonElementContext singletonElement() throws RecognitionException {
11778                SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState());
11779                enterRule(_localctx, 102, RULE_singletonElement);
11780                try {
11781                        setState(1356);
11782                        _errHandler.sync(this);
11783                        switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
11784                        case 1:
11785                                enterOuterAlt(_localctx, 1);
11786                                {
11787                                setState(1341);
11788                                singletonTag();
11789                                }
11790                                break;
11791                        case 2:
11792                                enterOuterAlt(_localctx, 2);
11793                                {
11794                                setState(1342);
11795                                areaTag();
11796                                }
11797                                break;
11798                        case 3:
11799                                enterOuterAlt(_localctx, 3);
11800                                {
11801                                setState(1343);
11802                                baseTag();
11803                                }
11804                                break;
11805                        case 4:
11806                                enterOuterAlt(_localctx, 4);
11807                                {
11808                                setState(1344);
11809                                basefontTag();
11810                                }
11811                                break;
11812                        case 5:
11813                                enterOuterAlt(_localctx, 5);
11814                                {
11815                                setState(1345);
11816                                brTag();
11817                                }
11818                                break;
11819                        case 6:
11820                                enterOuterAlt(_localctx, 6);
11821                                {
11822                                setState(1346);
11823                                colTag();
11824                                }
11825                                break;
11826                        case 7:
11827                                enterOuterAlt(_localctx, 7);
11828                                {
11829                                setState(1347);
11830                                frameTag();
11831                                }
11832                                break;
11833                        case 8:
11834                                enterOuterAlt(_localctx, 8);
11835                                {
11836                                setState(1348);
11837                                hrTag();
11838                                }
11839                                break;
11840                        case 9:
11841                                enterOuterAlt(_localctx, 9);
11842                                {
11843                                setState(1349);
11844                                imgTag();
11845                                }
11846                                break;
11847                        case 10:
11848                                enterOuterAlt(_localctx, 10);
11849                                {
11850                                setState(1350);
11851                                inputTag();
11852                                }
11853                                break;
11854                        case 11:
11855                                enterOuterAlt(_localctx, 11);
11856                                {
11857                                setState(1351);
11858                                isindexTag();
11859                                }
11860                                break;
11861                        case 12:
11862                                enterOuterAlt(_localctx, 12);
11863                                {
11864                                setState(1352);
11865                                linkTag();
11866                                }
11867                                break;
11868                        case 13:
11869                                enterOuterAlt(_localctx, 13);
11870                                {
11871                                setState(1353);
11872                                metaTag();
11873                                }
11874                                break;
11875                        case 14:
11876                                enterOuterAlt(_localctx, 14);
11877                                {
11878                                setState(1354);
11879                                paramTag();
11880                                }
11881                                break;
11882                        case 15:
11883                                enterOuterAlt(_localctx, 15);
11884                                {
11885                                setState(1355);
11886                                wrongSinletonTag();
11887                                }
11888                                break;
11889                        }
11890                }
11891                catch (RecognitionException re) {
11892                        _localctx.exception = re;
11893                        _errHandler.reportError(this, re);
11894                        _errHandler.recover(this, re);
11895                }
11896                finally {
11897                        exitRule();
11898                }
11899                return _localctx;
11900        }
11901
11902        public static class SingletonTagContext extends ParserRuleContext {
11903                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11904                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11905                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
11906                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
11907                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
11908                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
11909                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
11910                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
11911                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
11912                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
11913                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
11914                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
11915                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
11916                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
11917                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
11918                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
11919                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
11920                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11921                public List<AttributeContext> attribute() {
11922                        return getRuleContexts(AttributeContext.class);
11923                }
11924                public AttributeContext attribute(int i) {
11925                        return getRuleContext(AttributeContext.class,i);
11926                }
11927                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11928                public TerminalNode NEWLINE(int i) {
11929                        return getToken(JavadocParser.NEWLINE, i);
11930                }
11931                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11932                public TerminalNode LEADING_ASTERISK(int i) {
11933                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11934                }
11935                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11936                public TerminalNode WS(int i) {
11937                        return getToken(JavadocParser.WS, i);
11938                }
11939                public SingletonTagContext(ParserRuleContext parent, int invokingState) {
11940                        super(parent, invokingState);
11941                }
11942                @Override public int getRuleIndex() { return RULE_singletonTag; }
11943                @Override
11944                public void enterRule(ParseTreeListener listener) {
11945                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this);
11946                }
11947                @Override
11948                public void exitRule(ParseTreeListener listener) {
11949                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this);
11950                }
11951                @Override
11952                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11953                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this);
11954                        else return visitor.visitChildren(this);
11955                }
11956        }
11957
11958        public final SingletonTagContext singletonTag() throws RecognitionException {
11959                SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState());
11960                enterRule(_localctx, 104, RULE_singletonTag);
11961                int _la;
11962                try {
11963                        enterOuterAlt(_localctx, 1);
11964                        {
11965                        setState(1358);
11966                        match(OPEN);
11967                        setState(1359);
11968                        _la = _input.LA(1);
11969                        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)) ) {
11970                        _errHandler.recoverInline(this);
11971                        } else {
11972                                consume();
11973                        }
11974                        setState(1366);
11975                        _errHandler.sync(this);
11976                        _la = _input.LA(1);
11977                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11978                                {
11979                                setState(1364);
11980                                switch (_input.LA(1)) {
11981                                case HTML_TAG_NAME:
11982                                        {
11983                                        setState(1360);
11984                                        attribute();
11985                                        }
11986                                        break;
11987                                case NEWLINE:
11988                                        {
11989                                        setState(1361);
11990                                        match(NEWLINE);
11991                                        }
11992                                        break;
11993                                case LEADING_ASTERISK:
11994                                        {
11995                                        setState(1362);
11996                                        match(LEADING_ASTERISK);
11997                                        }
11998                                        break;
11999                                case WS:
12000                                        {
12001                                        setState(1363);
12002                                        match(WS);
12003                                        }
12004                                        break;
12005                                default:
12006                                        throw new NoViableAltException(this);
12007                                }
12008                                }
12009                                setState(1368);
12010                                _errHandler.sync(this);
12011                                _la = _input.LA(1);
12012                        }
12013                        setState(1369);
12014                        match(SLASH_CLOSE);
12015                        }
12016                }
12017                catch (RecognitionException re) {
12018                        _localctx.exception = re;
12019                        _errHandler.reportError(this, re);
12020                        _errHandler.recover(this, re);
12021                }
12022                finally {
12023                        exitRule();
12024                }
12025                return _localctx;
12026        }
12027
12028        public static class AreaTagContext extends ParserRuleContext {
12029                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12030                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
12031                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12032                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12033                public List<AttributeContext> attribute() {
12034                        return getRuleContexts(AttributeContext.class);
12035                }
12036                public AttributeContext attribute(int i) {
12037                        return getRuleContext(AttributeContext.class,i);
12038                }
12039                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12040                public TerminalNode NEWLINE(int i) {
12041                        return getToken(JavadocParser.NEWLINE, i);
12042                }
12043                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12044                public TerminalNode LEADING_ASTERISK(int i) {
12045                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12046                }
12047                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12048                public TerminalNode WS(int i) {
12049                        return getToken(JavadocParser.WS, i);
12050                }
12051                public AreaTagContext(ParserRuleContext parent, int invokingState) {
12052                        super(parent, invokingState);
12053                }
12054                @Override public int getRuleIndex() { return RULE_areaTag; }
12055                @Override
12056                public void enterRule(ParseTreeListener listener) {
12057                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this);
12058                }
12059                @Override
12060                public void exitRule(ParseTreeListener listener) {
12061                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this);
12062                }
12063                @Override
12064                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12065                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this);
12066                        else return visitor.visitChildren(this);
12067                }
12068        }
12069
12070        public final AreaTagContext areaTag() throws RecognitionException {
12071                AreaTagContext _localctx = new AreaTagContext(_ctx, getState());
12072                enterRule(_localctx, 106, RULE_areaTag);
12073                int _la;
12074                try {
12075                        enterOuterAlt(_localctx, 1);
12076                        {
12077                        setState(1371);
12078                        match(OPEN);
12079                        setState(1372);
12080                        match(AREA_HTML_TAG_NAME);
12081                        setState(1379);
12082                        _errHandler.sync(this);
12083                        _la = _input.LA(1);
12084                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12085                                {
12086                                setState(1377);
12087                                switch (_input.LA(1)) {
12088                                case HTML_TAG_NAME:
12089                                        {
12090                                        setState(1373);
12091                                        attribute();
12092                                        }
12093                                        break;
12094                                case NEWLINE:
12095                                        {
12096                                        setState(1374);
12097                                        match(NEWLINE);
12098                                        }
12099                                        break;
12100                                case LEADING_ASTERISK:
12101                                        {
12102                                        setState(1375);
12103                                        match(LEADING_ASTERISK);
12104                                        }
12105                                        break;
12106                                case WS:
12107                                        {
12108                                        setState(1376);
12109                                        match(WS);
12110                                        }
12111                                        break;
12112                                default:
12113                                        throw new NoViableAltException(this);
12114                                }
12115                                }
12116                                setState(1381);
12117                                _errHandler.sync(this);
12118                                _la = _input.LA(1);
12119                        }
12120                        setState(1382);
12121                        _la = _input.LA(1);
12122                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12123                        _errHandler.recoverInline(this);
12124                        } else {
12125                                consume();
12126                        }
12127                        }
12128                }
12129                catch (RecognitionException re) {
12130                        _localctx.exception = re;
12131                        _errHandler.reportError(this, re);
12132                        _errHandler.recover(this, re);
12133                }
12134                finally {
12135                        exitRule();
12136                }
12137                return _localctx;
12138        }
12139
12140        public static class BaseTagContext extends ParserRuleContext {
12141                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12142                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
12143                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12144                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12145                public List<AttributeContext> attribute() {
12146                        return getRuleContexts(AttributeContext.class);
12147                }
12148                public AttributeContext attribute(int i) {
12149                        return getRuleContext(AttributeContext.class,i);
12150                }
12151                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12152                public TerminalNode NEWLINE(int i) {
12153                        return getToken(JavadocParser.NEWLINE, i);
12154                }
12155                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12156                public TerminalNode LEADING_ASTERISK(int i) {
12157                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12158                }
12159                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12160                public TerminalNode WS(int i) {
12161                        return getToken(JavadocParser.WS, i);
12162                }
12163                public BaseTagContext(ParserRuleContext parent, int invokingState) {
12164                        super(parent, invokingState);
12165                }
12166                @Override public int getRuleIndex() { return RULE_baseTag; }
12167                @Override
12168                public void enterRule(ParseTreeListener listener) {
12169                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this);
12170                }
12171                @Override
12172                public void exitRule(ParseTreeListener listener) {
12173                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this);
12174                }
12175                @Override
12176                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12177                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this);
12178                        else return visitor.visitChildren(this);
12179                }
12180        }
12181
12182        public final BaseTagContext baseTag() throws RecognitionException {
12183                BaseTagContext _localctx = new BaseTagContext(_ctx, getState());
12184                enterRule(_localctx, 108, RULE_baseTag);
12185                int _la;
12186                try {
12187                        enterOuterAlt(_localctx, 1);
12188                        {
12189                        setState(1384);
12190                        match(OPEN);
12191                        setState(1385);
12192                        match(BASE_HTML_TAG_NAME);
12193                        setState(1392);
12194                        _errHandler.sync(this);
12195                        _la = _input.LA(1);
12196                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12197                                {
12198                                setState(1390);
12199                                switch (_input.LA(1)) {
12200                                case HTML_TAG_NAME:
12201                                        {
12202                                        setState(1386);
12203                                        attribute();
12204                                        }
12205                                        break;
12206                                case NEWLINE:
12207                                        {
12208                                        setState(1387);
12209                                        match(NEWLINE);
12210                                        }
12211                                        break;
12212                                case LEADING_ASTERISK:
12213                                        {
12214                                        setState(1388);
12215                                        match(LEADING_ASTERISK);
12216                                        }
12217                                        break;
12218                                case WS:
12219                                        {
12220                                        setState(1389);
12221                                        match(WS);
12222                                        }
12223                                        break;
12224                                default:
12225                                        throw new NoViableAltException(this);
12226                                }
12227                                }
12228                                setState(1394);
12229                                _errHandler.sync(this);
12230                                _la = _input.LA(1);
12231                        }
12232                        setState(1395);
12233                        _la = _input.LA(1);
12234                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12235                        _errHandler.recoverInline(this);
12236                        } else {
12237                                consume();
12238                        }
12239                        }
12240                }
12241                catch (RecognitionException re) {
12242                        _localctx.exception = re;
12243                        _errHandler.reportError(this, re);
12244                        _errHandler.recover(this, re);
12245                }
12246                finally {
12247                        exitRule();
12248                }
12249                return _localctx;
12250        }
12251
12252        public static class BasefontTagContext extends ParserRuleContext {
12253                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12254                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
12255                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12256                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12257                public List<AttributeContext> attribute() {
12258                        return getRuleContexts(AttributeContext.class);
12259                }
12260                public AttributeContext attribute(int i) {
12261                        return getRuleContext(AttributeContext.class,i);
12262                }
12263                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12264                public TerminalNode NEWLINE(int i) {
12265                        return getToken(JavadocParser.NEWLINE, i);
12266                }
12267                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12268                public TerminalNode LEADING_ASTERISK(int i) {
12269                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12270                }
12271                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12272                public TerminalNode WS(int i) {
12273                        return getToken(JavadocParser.WS, i);
12274                }
12275                public BasefontTagContext(ParserRuleContext parent, int invokingState) {
12276                        super(parent, invokingState);
12277                }
12278                @Override public int getRuleIndex() { return RULE_basefontTag; }
12279                @Override
12280                public void enterRule(ParseTreeListener listener) {
12281                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this);
12282                }
12283                @Override
12284                public void exitRule(ParseTreeListener listener) {
12285                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this);
12286                }
12287                @Override
12288                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12289                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this);
12290                        else return visitor.visitChildren(this);
12291                }
12292        }
12293
12294        public final BasefontTagContext basefontTag() throws RecognitionException {
12295                BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState());
12296                enterRule(_localctx, 110, RULE_basefontTag);
12297                int _la;
12298                try {
12299                        enterOuterAlt(_localctx, 1);
12300                        {
12301                        setState(1397);
12302                        match(OPEN);
12303                        setState(1398);
12304                        match(BASEFONT_HTML_TAG_NAME);
12305                        setState(1405);
12306                        _errHandler.sync(this);
12307                        _la = _input.LA(1);
12308                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12309                                {
12310                                setState(1403);
12311                                switch (_input.LA(1)) {
12312                                case HTML_TAG_NAME:
12313                                        {
12314                                        setState(1399);
12315                                        attribute();
12316                                        }
12317                                        break;
12318                                case NEWLINE:
12319                                        {
12320                                        setState(1400);
12321                                        match(NEWLINE);
12322                                        }
12323                                        break;
12324                                case LEADING_ASTERISK:
12325                                        {
12326                                        setState(1401);
12327                                        match(LEADING_ASTERISK);
12328                                        }
12329                                        break;
12330                                case WS:
12331                                        {
12332                                        setState(1402);
12333                                        match(WS);
12334                                        }
12335                                        break;
12336                                default:
12337                                        throw new NoViableAltException(this);
12338                                }
12339                                }
12340                                setState(1407);
12341                                _errHandler.sync(this);
12342                                _la = _input.LA(1);
12343                        }
12344                        setState(1408);
12345                        _la = _input.LA(1);
12346                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12347                        _errHandler.recoverInline(this);
12348                        } else {
12349                                consume();
12350                        }
12351                        }
12352                }
12353                catch (RecognitionException re) {
12354                        _localctx.exception = re;
12355                        _errHandler.reportError(this, re);
12356                        _errHandler.recover(this, re);
12357                }
12358                finally {
12359                        exitRule();
12360                }
12361                return _localctx;
12362        }
12363
12364        public static class BrTagContext extends ParserRuleContext {
12365                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12366                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
12367                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12368                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12369                public List<AttributeContext> attribute() {
12370                        return getRuleContexts(AttributeContext.class);
12371                }
12372                public AttributeContext attribute(int i) {
12373                        return getRuleContext(AttributeContext.class,i);
12374                }
12375                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12376                public TerminalNode NEWLINE(int i) {
12377                        return getToken(JavadocParser.NEWLINE, i);
12378                }
12379                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12380                public TerminalNode LEADING_ASTERISK(int i) {
12381                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12382                }
12383                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12384                public TerminalNode WS(int i) {
12385                        return getToken(JavadocParser.WS, i);
12386                }
12387                public BrTagContext(ParserRuleContext parent, int invokingState) {
12388                        super(parent, invokingState);
12389                }
12390                @Override public int getRuleIndex() { return RULE_brTag; }
12391                @Override
12392                public void enterRule(ParseTreeListener listener) {
12393                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this);
12394                }
12395                @Override
12396                public void exitRule(ParseTreeListener listener) {
12397                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this);
12398                }
12399                @Override
12400                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12401                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this);
12402                        else return visitor.visitChildren(this);
12403                }
12404        }
12405
12406        public final BrTagContext brTag() throws RecognitionException {
12407                BrTagContext _localctx = new BrTagContext(_ctx, getState());
12408                enterRule(_localctx, 112, RULE_brTag);
12409                int _la;
12410                try {
12411                        enterOuterAlt(_localctx, 1);
12412                        {
12413                        setState(1410);
12414                        match(OPEN);
12415                        setState(1411);
12416                        match(BR_HTML_TAG_NAME);
12417                        setState(1418);
12418                        _errHandler.sync(this);
12419                        _la = _input.LA(1);
12420                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12421                                {
12422                                setState(1416);
12423                                switch (_input.LA(1)) {
12424                                case HTML_TAG_NAME:
12425                                        {
12426                                        setState(1412);
12427                                        attribute();
12428                                        }
12429                                        break;
12430                                case NEWLINE:
12431                                        {
12432                                        setState(1413);
12433                                        match(NEWLINE);
12434                                        }
12435                                        break;
12436                                case LEADING_ASTERISK:
12437                                        {
12438                                        setState(1414);
12439                                        match(LEADING_ASTERISK);
12440                                        }
12441                                        break;
12442                                case WS:
12443                                        {
12444                                        setState(1415);
12445                                        match(WS);
12446                                        }
12447                                        break;
12448                                default:
12449                                        throw new NoViableAltException(this);
12450                                }
12451                                }
12452                                setState(1420);
12453                                _errHandler.sync(this);
12454                                _la = _input.LA(1);
12455                        }
12456                        setState(1421);
12457                        _la = _input.LA(1);
12458                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12459                        _errHandler.recoverInline(this);
12460                        } else {
12461                                consume();
12462                        }
12463                        }
12464                }
12465                catch (RecognitionException re) {
12466                        _localctx.exception = re;
12467                        _errHandler.reportError(this, re);
12468                        _errHandler.recover(this, re);
12469                }
12470                finally {
12471                        exitRule();
12472                }
12473                return _localctx;
12474        }
12475
12476        public static class ColTagContext extends ParserRuleContext {
12477                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12478                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
12479                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12480                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12481                public List<AttributeContext> attribute() {
12482                        return getRuleContexts(AttributeContext.class);
12483                }
12484                public AttributeContext attribute(int i) {
12485                        return getRuleContext(AttributeContext.class,i);
12486                }
12487                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12488                public TerminalNode NEWLINE(int i) {
12489                        return getToken(JavadocParser.NEWLINE, i);
12490                }
12491                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12492                public TerminalNode LEADING_ASTERISK(int i) {
12493                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12494                }
12495                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12496                public TerminalNode WS(int i) {
12497                        return getToken(JavadocParser.WS, i);
12498                }
12499                public ColTagContext(ParserRuleContext parent, int invokingState) {
12500                        super(parent, invokingState);
12501                }
12502                @Override public int getRuleIndex() { return RULE_colTag; }
12503                @Override
12504                public void enterRule(ParseTreeListener listener) {
12505                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this);
12506                }
12507                @Override
12508                public void exitRule(ParseTreeListener listener) {
12509                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this);
12510                }
12511                @Override
12512                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12513                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this);
12514                        else return visitor.visitChildren(this);
12515                }
12516        }
12517
12518        public final ColTagContext colTag() throws RecognitionException {
12519                ColTagContext _localctx = new ColTagContext(_ctx, getState());
12520                enterRule(_localctx, 114, RULE_colTag);
12521                int _la;
12522                try {
12523                        enterOuterAlt(_localctx, 1);
12524                        {
12525                        setState(1423);
12526                        match(OPEN);
12527                        setState(1424);
12528                        match(COL_HTML_TAG_NAME);
12529                        setState(1431);
12530                        _errHandler.sync(this);
12531                        _la = _input.LA(1);
12532                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12533                                {
12534                                setState(1429);
12535                                switch (_input.LA(1)) {
12536                                case HTML_TAG_NAME:
12537                                        {
12538                                        setState(1425);
12539                                        attribute();
12540                                        }
12541                                        break;
12542                                case NEWLINE:
12543                                        {
12544                                        setState(1426);
12545                                        match(NEWLINE);
12546                                        }
12547                                        break;
12548                                case LEADING_ASTERISK:
12549                                        {
12550                                        setState(1427);
12551                                        match(LEADING_ASTERISK);
12552                                        }
12553                                        break;
12554                                case WS:
12555                                        {
12556                                        setState(1428);
12557                                        match(WS);
12558                                        }
12559                                        break;
12560                                default:
12561                                        throw new NoViableAltException(this);
12562                                }
12563                                }
12564                                setState(1433);
12565                                _errHandler.sync(this);
12566                                _la = _input.LA(1);
12567                        }
12568                        setState(1434);
12569                        _la = _input.LA(1);
12570                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12571                        _errHandler.recoverInline(this);
12572                        } else {
12573                                consume();
12574                        }
12575                        }
12576                }
12577                catch (RecognitionException re) {
12578                        _localctx.exception = re;
12579                        _errHandler.reportError(this, re);
12580                        _errHandler.recover(this, re);
12581                }
12582                finally {
12583                        exitRule();
12584                }
12585                return _localctx;
12586        }
12587
12588        public static class FrameTagContext extends ParserRuleContext {
12589                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12590                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
12591                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12592                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12593                public List<AttributeContext> attribute() {
12594                        return getRuleContexts(AttributeContext.class);
12595                }
12596                public AttributeContext attribute(int i) {
12597                        return getRuleContext(AttributeContext.class,i);
12598                }
12599                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12600                public TerminalNode NEWLINE(int i) {
12601                        return getToken(JavadocParser.NEWLINE, i);
12602                }
12603                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12604                public TerminalNode LEADING_ASTERISK(int i) {
12605                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12606                }
12607                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12608                public TerminalNode WS(int i) {
12609                        return getToken(JavadocParser.WS, i);
12610                }
12611                public FrameTagContext(ParserRuleContext parent, int invokingState) {
12612                        super(parent, invokingState);
12613                }
12614                @Override public int getRuleIndex() { return RULE_frameTag; }
12615                @Override
12616                public void enterRule(ParseTreeListener listener) {
12617                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this);
12618                }
12619                @Override
12620                public void exitRule(ParseTreeListener listener) {
12621                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this);
12622                }
12623                @Override
12624                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12625                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this);
12626                        else return visitor.visitChildren(this);
12627                }
12628        }
12629
12630        public final FrameTagContext frameTag() throws RecognitionException {
12631                FrameTagContext _localctx = new FrameTagContext(_ctx, getState());
12632                enterRule(_localctx, 116, RULE_frameTag);
12633                int _la;
12634                try {
12635                        enterOuterAlt(_localctx, 1);
12636                        {
12637                        setState(1436);
12638                        match(OPEN);
12639                        setState(1437);
12640                        match(FRAME_HTML_TAG_NAME);
12641                        setState(1444);
12642                        _errHandler.sync(this);
12643                        _la = _input.LA(1);
12644                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12645                                {
12646                                setState(1442);
12647                                switch (_input.LA(1)) {
12648                                case HTML_TAG_NAME:
12649                                        {
12650                                        setState(1438);
12651                                        attribute();
12652                                        }
12653                                        break;
12654                                case NEWLINE:
12655                                        {
12656                                        setState(1439);
12657                                        match(NEWLINE);
12658                                        }
12659                                        break;
12660                                case LEADING_ASTERISK:
12661                                        {
12662                                        setState(1440);
12663                                        match(LEADING_ASTERISK);
12664                                        }
12665                                        break;
12666                                case WS:
12667                                        {
12668                                        setState(1441);
12669                                        match(WS);
12670                                        }
12671                                        break;
12672                                default:
12673                                        throw new NoViableAltException(this);
12674                                }
12675                                }
12676                                setState(1446);
12677                                _errHandler.sync(this);
12678                                _la = _input.LA(1);
12679                        }
12680                        setState(1447);
12681                        _la = _input.LA(1);
12682                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12683                        _errHandler.recoverInline(this);
12684                        } else {
12685                                consume();
12686                        }
12687                        }
12688                }
12689                catch (RecognitionException re) {
12690                        _localctx.exception = re;
12691                        _errHandler.reportError(this, re);
12692                        _errHandler.recover(this, re);
12693                }
12694                finally {
12695                        exitRule();
12696                }
12697                return _localctx;
12698        }
12699
12700        public static class HrTagContext extends ParserRuleContext {
12701                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12702                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
12703                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12704                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12705                public List<AttributeContext> attribute() {
12706                        return getRuleContexts(AttributeContext.class);
12707                }
12708                public AttributeContext attribute(int i) {
12709                        return getRuleContext(AttributeContext.class,i);
12710                }
12711                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12712                public TerminalNode NEWLINE(int i) {
12713                        return getToken(JavadocParser.NEWLINE, i);
12714                }
12715                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12716                public TerminalNode LEADING_ASTERISK(int i) {
12717                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12718                }
12719                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12720                public TerminalNode WS(int i) {
12721                        return getToken(JavadocParser.WS, i);
12722                }
12723                public HrTagContext(ParserRuleContext parent, int invokingState) {
12724                        super(parent, invokingState);
12725                }
12726                @Override public int getRuleIndex() { return RULE_hrTag; }
12727                @Override
12728                public void enterRule(ParseTreeListener listener) {
12729                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this);
12730                }
12731                @Override
12732                public void exitRule(ParseTreeListener listener) {
12733                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this);
12734                }
12735                @Override
12736                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12737                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this);
12738                        else return visitor.visitChildren(this);
12739                }
12740        }
12741
12742        public final HrTagContext hrTag() throws RecognitionException {
12743                HrTagContext _localctx = new HrTagContext(_ctx, getState());
12744                enterRule(_localctx, 118, RULE_hrTag);
12745                int _la;
12746                try {
12747                        enterOuterAlt(_localctx, 1);
12748                        {
12749                        setState(1449);
12750                        match(OPEN);
12751                        setState(1450);
12752                        match(HR_HTML_TAG_NAME);
12753                        setState(1457);
12754                        _errHandler.sync(this);
12755                        _la = _input.LA(1);
12756                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12757                                {
12758                                setState(1455);
12759                                switch (_input.LA(1)) {
12760                                case HTML_TAG_NAME:
12761                                        {
12762                                        setState(1451);
12763                                        attribute();
12764                                        }
12765                                        break;
12766                                case NEWLINE:
12767                                        {
12768                                        setState(1452);
12769                                        match(NEWLINE);
12770                                        }
12771                                        break;
12772                                case LEADING_ASTERISK:
12773                                        {
12774                                        setState(1453);
12775                                        match(LEADING_ASTERISK);
12776                                        }
12777                                        break;
12778                                case WS:
12779                                        {
12780                                        setState(1454);
12781                                        match(WS);
12782                                        }
12783                                        break;
12784                                default:
12785                                        throw new NoViableAltException(this);
12786                                }
12787                                }
12788                                setState(1459);
12789                                _errHandler.sync(this);
12790                                _la = _input.LA(1);
12791                        }
12792                        setState(1460);
12793                        _la = _input.LA(1);
12794                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12795                        _errHandler.recoverInline(this);
12796                        } else {
12797                                consume();
12798                        }
12799                        }
12800                }
12801                catch (RecognitionException re) {
12802                        _localctx.exception = re;
12803                        _errHandler.reportError(this, re);
12804                        _errHandler.recover(this, re);
12805                }
12806                finally {
12807                        exitRule();
12808                }
12809                return _localctx;
12810        }
12811
12812        public static class ImgTagContext extends ParserRuleContext {
12813                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12814                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
12815                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12816                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12817                public List<AttributeContext> attribute() {
12818                        return getRuleContexts(AttributeContext.class);
12819                }
12820                public AttributeContext attribute(int i) {
12821                        return getRuleContext(AttributeContext.class,i);
12822                }
12823                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12824                public TerminalNode NEWLINE(int i) {
12825                        return getToken(JavadocParser.NEWLINE, i);
12826                }
12827                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12828                public TerminalNode LEADING_ASTERISK(int i) {
12829                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12830                }
12831                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12832                public TerminalNode WS(int i) {
12833                        return getToken(JavadocParser.WS, i);
12834                }
12835                public ImgTagContext(ParserRuleContext parent, int invokingState) {
12836                        super(parent, invokingState);
12837                }
12838                @Override public int getRuleIndex() { return RULE_imgTag; }
12839                @Override
12840                public void enterRule(ParseTreeListener listener) {
12841                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this);
12842                }
12843                @Override
12844                public void exitRule(ParseTreeListener listener) {
12845                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this);
12846                }
12847                @Override
12848                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12849                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this);
12850                        else return visitor.visitChildren(this);
12851                }
12852        }
12853
12854        public final ImgTagContext imgTag() throws RecognitionException {
12855                ImgTagContext _localctx = new ImgTagContext(_ctx, getState());
12856                enterRule(_localctx, 120, RULE_imgTag);
12857                int _la;
12858                try {
12859                        enterOuterAlt(_localctx, 1);
12860                        {
12861                        setState(1462);
12862                        match(OPEN);
12863                        setState(1463);
12864                        match(IMG_HTML_TAG_NAME);
12865                        setState(1470);
12866                        _errHandler.sync(this);
12867                        _la = _input.LA(1);
12868                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12869                                {
12870                                setState(1468);
12871                                switch (_input.LA(1)) {
12872                                case HTML_TAG_NAME:
12873                                        {
12874                                        setState(1464);
12875                                        attribute();
12876                                        }
12877                                        break;
12878                                case NEWLINE:
12879                                        {
12880                                        setState(1465);
12881                                        match(NEWLINE);
12882                                        }
12883                                        break;
12884                                case LEADING_ASTERISK:
12885                                        {
12886                                        setState(1466);
12887                                        match(LEADING_ASTERISK);
12888                                        }
12889                                        break;
12890                                case WS:
12891                                        {
12892                                        setState(1467);
12893                                        match(WS);
12894                                        }
12895                                        break;
12896                                default:
12897                                        throw new NoViableAltException(this);
12898                                }
12899                                }
12900                                setState(1472);
12901                                _errHandler.sync(this);
12902                                _la = _input.LA(1);
12903                        }
12904                        setState(1473);
12905                        _la = _input.LA(1);
12906                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12907                        _errHandler.recoverInline(this);
12908                        } else {
12909                                consume();
12910                        }
12911                        }
12912                }
12913                catch (RecognitionException re) {
12914                        _localctx.exception = re;
12915                        _errHandler.reportError(this, re);
12916                        _errHandler.recover(this, re);
12917                }
12918                finally {
12919                        exitRule();
12920                }
12921                return _localctx;
12922        }
12923
12924        public static class InputTagContext extends ParserRuleContext {
12925                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12926                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
12927                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12928                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12929                public List<AttributeContext> attribute() {
12930                        return getRuleContexts(AttributeContext.class);
12931                }
12932                public AttributeContext attribute(int i) {
12933                        return getRuleContext(AttributeContext.class,i);
12934                }
12935                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12936                public TerminalNode NEWLINE(int i) {
12937                        return getToken(JavadocParser.NEWLINE, i);
12938                }
12939                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12940                public TerminalNode LEADING_ASTERISK(int i) {
12941                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12942                }
12943                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12944                public TerminalNode WS(int i) {
12945                        return getToken(JavadocParser.WS, i);
12946                }
12947                public InputTagContext(ParserRuleContext parent, int invokingState) {
12948                        super(parent, invokingState);
12949                }
12950                @Override public int getRuleIndex() { return RULE_inputTag; }
12951                @Override
12952                public void enterRule(ParseTreeListener listener) {
12953                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this);
12954                }
12955                @Override
12956                public void exitRule(ParseTreeListener listener) {
12957                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this);
12958                }
12959                @Override
12960                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12961                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this);
12962                        else return visitor.visitChildren(this);
12963                }
12964        }
12965
12966        public final InputTagContext inputTag() throws RecognitionException {
12967                InputTagContext _localctx = new InputTagContext(_ctx, getState());
12968                enterRule(_localctx, 122, RULE_inputTag);
12969                int _la;
12970                try {
12971                        enterOuterAlt(_localctx, 1);
12972                        {
12973                        setState(1475);
12974                        match(OPEN);
12975                        setState(1476);
12976                        match(INPUT_HTML_TAG_NAME);
12977                        setState(1483);
12978                        _errHandler.sync(this);
12979                        _la = _input.LA(1);
12980                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12981                                {
12982                                setState(1481);
12983                                switch (_input.LA(1)) {
12984                                case HTML_TAG_NAME:
12985                                        {
12986                                        setState(1477);
12987                                        attribute();
12988                                        }
12989                                        break;
12990                                case NEWLINE:
12991                                        {
12992                                        setState(1478);
12993                                        match(NEWLINE);
12994                                        }
12995                                        break;
12996                                case LEADING_ASTERISK:
12997                                        {
12998                                        setState(1479);
12999                                        match(LEADING_ASTERISK);
13000                                        }
13001                                        break;
13002                                case WS:
13003                                        {
13004                                        setState(1480);
13005                                        match(WS);
13006                                        }
13007                                        break;
13008                                default:
13009                                        throw new NoViableAltException(this);
13010                                }
13011                                }
13012                                setState(1485);
13013                                _errHandler.sync(this);
13014                                _la = _input.LA(1);
13015                        }
13016                        setState(1486);
13017                        _la = _input.LA(1);
13018                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13019                        _errHandler.recoverInline(this);
13020                        } else {
13021                                consume();
13022                        }
13023                        }
13024                }
13025                catch (RecognitionException re) {
13026                        _localctx.exception = re;
13027                        _errHandler.reportError(this, re);
13028                        _errHandler.recover(this, re);
13029                }
13030                finally {
13031                        exitRule();
13032                }
13033                return _localctx;
13034        }
13035
13036        public static class IsindexTagContext extends ParserRuleContext {
13037                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13038                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13039                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13040                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13041                public List<AttributeContext> attribute() {
13042                        return getRuleContexts(AttributeContext.class);
13043                }
13044                public AttributeContext attribute(int i) {
13045                        return getRuleContext(AttributeContext.class,i);
13046                }
13047                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13048                public TerminalNode NEWLINE(int i) {
13049                        return getToken(JavadocParser.NEWLINE, i);
13050                }
13051                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13052                public TerminalNode LEADING_ASTERISK(int i) {
13053                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13054                }
13055                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13056                public TerminalNode WS(int i) {
13057                        return getToken(JavadocParser.WS, i);
13058                }
13059                public IsindexTagContext(ParserRuleContext parent, int invokingState) {
13060                        super(parent, invokingState);
13061                }
13062                @Override public int getRuleIndex() { return RULE_isindexTag; }
13063                @Override
13064                public void enterRule(ParseTreeListener listener) {
13065                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this);
13066                }
13067                @Override
13068                public void exitRule(ParseTreeListener listener) {
13069                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this);
13070                }
13071                @Override
13072                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13073                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this);
13074                        else return visitor.visitChildren(this);
13075                }
13076        }
13077
13078        public final IsindexTagContext isindexTag() throws RecognitionException {
13079                IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState());
13080                enterRule(_localctx, 124, RULE_isindexTag);
13081                int _la;
13082                try {
13083                        enterOuterAlt(_localctx, 1);
13084                        {
13085                        setState(1488);
13086                        match(OPEN);
13087                        setState(1489);
13088                        match(ISINDEX_HTML_TAG_NAME);
13089                        setState(1496);
13090                        _errHandler.sync(this);
13091                        _la = _input.LA(1);
13092                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13093                                {
13094                                setState(1494);
13095                                switch (_input.LA(1)) {
13096                                case HTML_TAG_NAME:
13097                                        {
13098                                        setState(1490);
13099                                        attribute();
13100                                        }
13101                                        break;
13102                                case NEWLINE:
13103                                        {
13104                                        setState(1491);
13105                                        match(NEWLINE);
13106                                        }
13107                                        break;
13108                                case LEADING_ASTERISK:
13109                                        {
13110                                        setState(1492);
13111                                        match(LEADING_ASTERISK);
13112                                        }
13113                                        break;
13114                                case WS:
13115                                        {
13116                                        setState(1493);
13117                                        match(WS);
13118                                        }
13119                                        break;
13120                                default:
13121                                        throw new NoViableAltException(this);
13122                                }
13123                                }
13124                                setState(1498);
13125                                _errHandler.sync(this);
13126                                _la = _input.LA(1);
13127                        }
13128                        setState(1499);
13129                        _la = _input.LA(1);
13130                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13131                        _errHandler.recoverInline(this);
13132                        } else {
13133                                consume();
13134                        }
13135                        }
13136                }
13137                catch (RecognitionException re) {
13138                        _localctx.exception = re;
13139                        _errHandler.reportError(this, re);
13140                        _errHandler.recover(this, re);
13141                }
13142                finally {
13143                        exitRule();
13144                }
13145                return _localctx;
13146        }
13147
13148        public static class LinkTagContext extends ParserRuleContext {
13149                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13150                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13151                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13152                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13153                public List<AttributeContext> attribute() {
13154                        return getRuleContexts(AttributeContext.class);
13155                }
13156                public AttributeContext attribute(int i) {
13157                        return getRuleContext(AttributeContext.class,i);
13158                }
13159                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13160                public TerminalNode NEWLINE(int i) {
13161                        return getToken(JavadocParser.NEWLINE, i);
13162                }
13163                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13164                public TerminalNode LEADING_ASTERISK(int i) {
13165                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13166                }
13167                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13168                public TerminalNode WS(int i) {
13169                        return getToken(JavadocParser.WS, i);
13170                }
13171                public LinkTagContext(ParserRuleContext parent, int invokingState) {
13172                        super(parent, invokingState);
13173                }
13174                @Override public int getRuleIndex() { return RULE_linkTag; }
13175                @Override
13176                public void enterRule(ParseTreeListener listener) {
13177                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this);
13178                }
13179                @Override
13180                public void exitRule(ParseTreeListener listener) {
13181                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this);
13182                }
13183                @Override
13184                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13185                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this);
13186                        else return visitor.visitChildren(this);
13187                }
13188        }
13189
13190        public final LinkTagContext linkTag() throws RecognitionException {
13191                LinkTagContext _localctx = new LinkTagContext(_ctx, getState());
13192                enterRule(_localctx, 126, RULE_linkTag);
13193                int _la;
13194                try {
13195                        enterOuterAlt(_localctx, 1);
13196                        {
13197                        setState(1501);
13198                        match(OPEN);
13199                        setState(1502);
13200                        match(LINK_HTML_TAG_NAME);
13201                        setState(1509);
13202                        _errHandler.sync(this);
13203                        _la = _input.LA(1);
13204                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13205                                {
13206                                setState(1507);
13207                                switch (_input.LA(1)) {
13208                                case HTML_TAG_NAME:
13209                                        {
13210                                        setState(1503);
13211                                        attribute();
13212                                        }
13213                                        break;
13214                                case NEWLINE:
13215                                        {
13216                                        setState(1504);
13217                                        match(NEWLINE);
13218                                        }
13219                                        break;
13220                                case LEADING_ASTERISK:
13221                                        {
13222                                        setState(1505);
13223                                        match(LEADING_ASTERISK);
13224                                        }
13225                                        break;
13226                                case WS:
13227                                        {
13228                                        setState(1506);
13229                                        match(WS);
13230                                        }
13231                                        break;
13232                                default:
13233                                        throw new NoViableAltException(this);
13234                                }
13235                                }
13236                                setState(1511);
13237                                _errHandler.sync(this);
13238                                _la = _input.LA(1);
13239                        }
13240                        setState(1512);
13241                        _la = _input.LA(1);
13242                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13243                        _errHandler.recoverInline(this);
13244                        } else {
13245                                consume();
13246                        }
13247                        }
13248                }
13249                catch (RecognitionException re) {
13250                        _localctx.exception = re;
13251                        _errHandler.reportError(this, re);
13252                        _errHandler.recover(this, re);
13253                }
13254                finally {
13255                        exitRule();
13256                }
13257                return _localctx;
13258        }
13259
13260        public static class MetaTagContext extends ParserRuleContext {
13261                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13262                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13263                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13264                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13265                public List<AttributeContext> attribute() {
13266                        return getRuleContexts(AttributeContext.class);
13267                }
13268                public AttributeContext attribute(int i) {
13269                        return getRuleContext(AttributeContext.class,i);
13270                }
13271                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13272                public TerminalNode NEWLINE(int i) {
13273                        return getToken(JavadocParser.NEWLINE, i);
13274                }
13275                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13276                public TerminalNode LEADING_ASTERISK(int i) {
13277                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13278                }
13279                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13280                public TerminalNode WS(int i) {
13281                        return getToken(JavadocParser.WS, i);
13282                }
13283                public MetaTagContext(ParserRuleContext parent, int invokingState) {
13284                        super(parent, invokingState);
13285                }
13286                @Override public int getRuleIndex() { return RULE_metaTag; }
13287                @Override
13288                public void enterRule(ParseTreeListener listener) {
13289                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this);
13290                }
13291                @Override
13292                public void exitRule(ParseTreeListener listener) {
13293                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this);
13294                }
13295                @Override
13296                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13297                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this);
13298                        else return visitor.visitChildren(this);
13299                }
13300        }
13301
13302        public final MetaTagContext metaTag() throws RecognitionException {
13303                MetaTagContext _localctx = new MetaTagContext(_ctx, getState());
13304                enterRule(_localctx, 128, RULE_metaTag);
13305                int _la;
13306                try {
13307                        enterOuterAlt(_localctx, 1);
13308                        {
13309                        setState(1514);
13310                        match(OPEN);
13311                        setState(1515);
13312                        match(META_HTML_TAG_NAME);
13313                        setState(1522);
13314                        _errHandler.sync(this);
13315                        _la = _input.LA(1);
13316                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13317                                {
13318                                setState(1520);
13319                                switch (_input.LA(1)) {
13320                                case HTML_TAG_NAME:
13321                                        {
13322                                        setState(1516);
13323                                        attribute();
13324                                        }
13325                                        break;
13326                                case NEWLINE:
13327                                        {
13328                                        setState(1517);
13329                                        match(NEWLINE);
13330                                        }
13331                                        break;
13332                                case LEADING_ASTERISK:
13333                                        {
13334                                        setState(1518);
13335                                        match(LEADING_ASTERISK);
13336                                        }
13337                                        break;
13338                                case WS:
13339                                        {
13340                                        setState(1519);
13341                                        match(WS);
13342                                        }
13343                                        break;
13344                                default:
13345                                        throw new NoViableAltException(this);
13346                                }
13347                                }
13348                                setState(1524);
13349                                _errHandler.sync(this);
13350                                _la = _input.LA(1);
13351                        }
13352                        setState(1525);
13353                        _la = _input.LA(1);
13354                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13355                        _errHandler.recoverInline(this);
13356                        } else {
13357                                consume();
13358                        }
13359                        }
13360                }
13361                catch (RecognitionException re) {
13362                        _localctx.exception = re;
13363                        _errHandler.reportError(this, re);
13364                        _errHandler.recover(this, re);
13365                }
13366                finally {
13367                        exitRule();
13368                }
13369                return _localctx;
13370        }
13371
13372        public static class ParamTagContext extends ParserRuleContext {
13373                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13374                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13375                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13376                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13377                public List<AttributeContext> attribute() {
13378                        return getRuleContexts(AttributeContext.class);
13379                }
13380                public AttributeContext attribute(int i) {
13381                        return getRuleContext(AttributeContext.class,i);
13382                }
13383                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13384                public TerminalNode NEWLINE(int i) {
13385                        return getToken(JavadocParser.NEWLINE, i);
13386                }
13387                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13388                public TerminalNode LEADING_ASTERISK(int i) {
13389                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13390                }
13391                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13392                public TerminalNode WS(int i) {
13393                        return getToken(JavadocParser.WS, i);
13394                }
13395                public ParamTagContext(ParserRuleContext parent, int invokingState) {
13396                        super(parent, invokingState);
13397                }
13398                @Override public int getRuleIndex() { return RULE_paramTag; }
13399                @Override
13400                public void enterRule(ParseTreeListener listener) {
13401                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this);
13402                }
13403                @Override
13404                public void exitRule(ParseTreeListener listener) {
13405                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this);
13406                }
13407                @Override
13408                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13409                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this);
13410                        else return visitor.visitChildren(this);
13411                }
13412        }
13413
13414        public final ParamTagContext paramTag() throws RecognitionException {
13415                ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
13416                enterRule(_localctx, 130, RULE_paramTag);
13417                int _la;
13418                try {
13419                        enterOuterAlt(_localctx, 1);
13420                        {
13421                        setState(1527);
13422                        match(OPEN);
13423                        setState(1528);
13424                        match(PARAM_HTML_TAG_NAME);
13425                        setState(1535);
13426                        _errHandler.sync(this);
13427                        _la = _input.LA(1);
13428                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13429                                {
13430                                setState(1533);
13431                                switch (_input.LA(1)) {
13432                                case HTML_TAG_NAME:
13433                                        {
13434                                        setState(1529);
13435                                        attribute();
13436                                        }
13437                                        break;
13438                                case NEWLINE:
13439                                        {
13440                                        setState(1530);
13441                                        match(NEWLINE);
13442                                        }
13443                                        break;
13444                                case LEADING_ASTERISK:
13445                                        {
13446                                        setState(1531);
13447                                        match(LEADING_ASTERISK);
13448                                        }
13449                                        break;
13450                                case WS:
13451                                        {
13452                                        setState(1532);
13453                                        match(WS);
13454                                        }
13455                                        break;
13456                                default:
13457                                        throw new NoViableAltException(this);
13458                                }
13459                                }
13460                                setState(1537);
13461                                _errHandler.sync(this);
13462                                _la = _input.LA(1);
13463                        }
13464                        setState(1538);
13465                        _la = _input.LA(1);
13466                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13467                        _errHandler.recoverInline(this);
13468                        } else {
13469                                consume();
13470                        }
13471                        }
13472                }
13473                catch (RecognitionException re) {
13474                        _localctx.exception = re;
13475                        _errHandler.reportError(this, re);
13476                        _errHandler.recover(this, re);
13477                }
13478                finally {
13479                        exitRule();
13480                }
13481                return _localctx;
13482        }
13483
13484        public static class WrongSinletonTagContext extends ParserRuleContext {
13485                public SingletonTagNameContext singletonTagName;
13486                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13487                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
13488                public SingletonTagNameContext singletonTagName() {
13489                        return getRuleContext(SingletonTagNameContext.class,0);
13490                }
13491                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13492                public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) {
13493                        super(parent, invokingState);
13494                }
13495                @Override public int getRuleIndex() { return RULE_wrongSinletonTag; }
13496                @Override
13497                public void enterRule(ParseTreeListener listener) {
13498                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this);
13499                }
13500                @Override
13501                public void exitRule(ParseTreeListener listener) {
13502                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this);
13503                }
13504                @Override
13505                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13506                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this);
13507                        else return visitor.visitChildren(this);
13508                }
13509        }
13510
13511        public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException {
13512                WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState());
13513                enterRule(_localctx, 132, RULE_wrongSinletonTag);
13514                try {
13515                        enterOuterAlt(_localctx, 1);
13516                        {
13517                        setState(1540);
13518                        match(OPEN);
13519                        setState(1541);
13520                        match(SLASH);
13521                        setState(1542);
13522                        ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName();
13523                        setState(1543);
13524                        match(CLOSE);
13525                        notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null),
13526                                                     "javadoc.wrong.singleton.html.tag", null);
13527                        }
13528                }
13529                catch (RecognitionException re) {
13530                        _localctx.exception = re;
13531                        _errHandler.reportError(this, re);
13532                        _errHandler.recover(this, re);
13533                }
13534                finally {
13535                        exitRule();
13536                }
13537                return _localctx;
13538        }
13539
13540        public static class SingletonTagNameContext extends ParserRuleContext {
13541                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
13542                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
13543                public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); }
13544                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
13545                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
13546                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
13547                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
13548                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
13549                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13550                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13551                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13552                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13553                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13554                public SingletonTagNameContext(ParserRuleContext parent, int invokingState) {
13555                        super(parent, invokingState);
13556                }
13557                @Override public int getRuleIndex() { return RULE_singletonTagName; }
13558                @Override
13559                public void enterRule(ParseTreeListener listener) {
13560                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this);
13561                }
13562                @Override
13563                public void exitRule(ParseTreeListener listener) {
13564                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this);
13565                }
13566                @Override
13567                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13568                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this);
13569                        else return visitor.visitChildren(this);
13570                }
13571        }
13572
13573        public final SingletonTagNameContext singletonTagName() throws RecognitionException {
13574                SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState());
13575                enterRule(_localctx, 134, RULE_singletonTagName);
13576                int _la;
13577                try {
13578                        enterOuterAlt(_localctx, 1);
13579                        {
13580                        setState(1546);
13581                        _la = _input.LA(1);
13582                        if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)))) != 0)) ) {
13583                        _errHandler.recoverInline(this);
13584                        } else {
13585                                consume();
13586                        }
13587                        }
13588                }
13589                catch (RecognitionException re) {
13590                        _localctx.exception = re;
13591                        _errHandler.reportError(this, re);
13592                        _errHandler.recover(this, re);
13593                }
13594                finally {
13595                        exitRule();
13596                }
13597                return _localctx;
13598        }
13599
13600        public static class DescriptionContext extends ParserRuleContext {
13601                public List<HtmlCommentContext> htmlComment() {
13602                        return getRuleContexts(HtmlCommentContext.class);
13603                }
13604                public HtmlCommentContext htmlComment(int i) {
13605                        return getRuleContext(HtmlCommentContext.class,i);
13606                }
13607                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
13608                public TerminalNode CDATA(int i) {
13609                        return getToken(JavadocParser.CDATA, i);
13610                }
13611                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13612                public TerminalNode NEWLINE(int i) {
13613                        return getToken(JavadocParser.NEWLINE, i);
13614                }
13615                public List<TextContext> text() {
13616                        return getRuleContexts(TextContext.class);
13617                }
13618                public TextContext text(int i) {
13619                        return getRuleContext(TextContext.class,i);
13620                }
13621                public List<JavadocInlineTagContext> javadocInlineTag() {
13622                        return getRuleContexts(JavadocInlineTagContext.class);
13623                }
13624                public JavadocInlineTagContext javadocInlineTag(int i) {
13625                        return getRuleContext(JavadocInlineTagContext.class,i);
13626                }
13627                public List<HtmlElementContext> htmlElement() {
13628                        return getRuleContexts(HtmlElementContext.class);
13629                }
13630                public HtmlElementContext htmlElement(int i) {
13631                        return getRuleContext(HtmlElementContext.class,i);
13632                }
13633                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13634                public TerminalNode LEADING_ASTERISK(int i) {
13635                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13636                }
13637                public DescriptionContext(ParserRuleContext parent, int invokingState) {
13638                        super(parent, invokingState);
13639                }
13640                @Override public int getRuleIndex() { return RULE_description; }
13641                @Override
13642                public void enterRule(ParseTreeListener listener) {
13643                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
13644                }
13645                @Override
13646                public void exitRule(ParseTreeListener listener) {
13647                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
13648                }
13649                @Override
13650                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13651                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
13652                        else return visitor.visitChildren(this);
13653                }
13654        }
13655
13656        public final DescriptionContext description() throws RecognitionException {
13657                DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
13658                enterRule(_localctx, 136, RULE_description);
13659                try {
13660                        int _alt;
13661                        enterOuterAlt(_localctx, 1);
13662                        {
13663                        setState(1556); 
13664                        _errHandler.sync(this);
13665                        _alt = 1;
13666                        do {
13667                                switch (_alt) {
13668                                case 1:
13669                                        {
13670                                        setState(1556);
13671                                        _errHandler.sync(this);
13672                                        switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
13673                                        case 1:
13674                                                {
13675                                                {
13676                                                setState(1548);
13677                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
13678                                                setState(1549);
13679                                                match(LEADING_ASTERISK);
13680                                                }
13681                                                }
13682                                                break;
13683                                        case 2:
13684                                                {
13685                                                setState(1550);
13686                                                htmlComment();
13687                                                }
13688                                                break;
13689                                        case 3:
13690                                                {
13691                                                setState(1551);
13692                                                match(CDATA);
13693                                                }
13694                                                break;
13695                                        case 4:
13696                                                {
13697                                                setState(1552);
13698                                                match(NEWLINE);
13699                                                }
13700                                                break;
13701                                        case 5:
13702                                                {
13703                                                setState(1553);
13704                                                text();
13705                                                }
13706                                                break;
13707                                        case 6:
13708                                                {
13709                                                setState(1554);
13710                                                javadocInlineTag();
13711                                                }
13712                                                break;
13713                                        case 7:
13714                                                {
13715                                                setState(1555);
13716                                                htmlElement();
13717                                                }
13718                                                break;
13719                                        }
13720                                        }
13721                                        break;
13722                                default:
13723                                        throw new NoViableAltException(this);
13724                                }
13725                                setState(1558); 
13726                                _errHandler.sync(this);
13727                                _alt = getInterpreter().adaptivePredict(_input,122,_ctx);
13728                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13729                        }
13730                }
13731                catch (RecognitionException re) {
13732                        _localctx.exception = re;
13733                        _errHandler.reportError(this, re);
13734                        _errHandler.recover(this, re);
13735                }
13736                finally {
13737                        exitRule();
13738                }
13739                return _localctx;
13740        }
13741
13742        public static class ReferenceContext extends ParserRuleContext {
13743                public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); }
13744                public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); }
13745                public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); }
13746                public ParametersContext parameters() {
13747                        return getRuleContext(ParametersContext.class,0);
13748                }
13749                public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); }
13750                public TerminalNode DOT(int i) {
13751                        return getToken(JavadocParser.DOT, i);
13752                }
13753                public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); }
13754                public TerminalNode CLASS(int i) {
13755                        return getToken(JavadocParser.CLASS, i);
13756                }
13757                public ReferenceContext(ParserRuleContext parent, int invokingState) {
13758                        super(parent, invokingState);
13759                }
13760                @Override public int getRuleIndex() { return RULE_reference; }
13761                @Override
13762                public void enterRule(ParseTreeListener listener) {
13763                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this);
13764                }
13765                @Override
13766                public void exitRule(ParseTreeListener listener) {
13767                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this);
13768                }
13769                @Override
13770                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13771                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this);
13772                        else return visitor.visitChildren(this);
13773                }
13774        }
13775
13776        public final ReferenceContext reference() throws RecognitionException {
13777                ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
13778                enterRule(_localctx, 138, RULE_reference);
13779                int _la;
13780                try {
13781                        int _alt;
13782                        enterOuterAlt(_localctx, 1);
13783                        {
13784                        setState(1597);
13785                        switch (_input.LA(1)) {
13786                        case PACKAGE:
13787                                {
13788                                setState(1560);
13789                                match(PACKAGE);
13790                                setState(1564);
13791                                _errHandler.sync(this);
13792                                _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13793                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13794                                        if ( _alt==1 ) {
13795                                                {
13796                                                {
13797                                                setState(1561);
13798                                                _la = _input.LA(1);
13799                                                if ( !(_la==DOT || _la==CLASS) ) {
13800                                                _errHandler.recoverInline(this);
13801                                                } else {
13802                                                        consume();
13803                                                }
13804                                                }
13805                                                } 
13806                                        }
13807                                        setState(1566);
13808                                        _errHandler.sync(this);
13809                                        _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13810                                }
13811                                setState(1568);
13812                                _errHandler.sync(this);
13813                                switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
13814                                case 1:
13815                                        {
13816                                        setState(1567);
13817                                        match(HASH);
13818                                        }
13819                                        break;
13820                                }
13821                                setState(1571);
13822                                _errHandler.sync(this);
13823                                switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
13824                                case 1:
13825                                        {
13826                                        setState(1570);
13827                                        match(MEMBER);
13828                                        }
13829                                        break;
13830                                }
13831                                setState(1574);
13832                                _errHandler.sync(this);
13833                                switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
13834                                case 1:
13835                                        {
13836                                        setState(1573);
13837                                        parameters();
13838                                        }
13839                                        break;
13840                                }
13841                                }
13842                                break;
13843                        case DOT:
13844                        case CLASS:
13845                                {
13846                                setState(1577); 
13847                                _errHandler.sync(this);
13848                                _alt = 1;
13849                                do {
13850                                        switch (_alt) {
13851                                        case 1:
13852                                                {
13853                                                {
13854                                                setState(1576);
13855                                                _la = _input.LA(1);
13856                                                if ( !(_la==DOT || _la==CLASS) ) {
13857                                                _errHandler.recoverInline(this);
13858                                                } else {
13859                                                        consume();
13860                                                }
13861                                                }
13862                                                }
13863                                                break;
13864                                        default:
13865                                                throw new NoViableAltException(this);
13866                                        }
13867                                        setState(1579); 
13868                                        _errHandler.sync(this);
13869                                        _alt = getInterpreter().adaptivePredict(_input,127,_ctx);
13870                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13871                                setState(1582);
13872                                _errHandler.sync(this);
13873                                switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
13874                                case 1:
13875                                        {
13876                                        setState(1581);
13877                                        match(HASH);
13878                                        }
13879                                        break;
13880                                }
13881                                setState(1585);
13882                                _errHandler.sync(this);
13883                                switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
13884                                case 1:
13885                                        {
13886                                        setState(1584);
13887                                        match(MEMBER);
13888                                        }
13889                                        break;
13890                                }
13891                                setState(1588);
13892                                _errHandler.sync(this);
13893                                switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
13894                                case 1:
13895                                        {
13896                                        setState(1587);
13897                                        parameters();
13898                                        }
13899                                        break;
13900                                }
13901                                }
13902                                break;
13903                        case HASH:
13904                        case MEMBER:
13905                                {
13906                                setState(1591);
13907                                _la = _input.LA(1);
13908                                if (_la==HASH) {
13909                                        {
13910                                        setState(1590);
13911                                        match(HASH);
13912                                        }
13913                                }
13914
13915                                setState(1593);
13916                                match(MEMBER);
13917                                setState(1595);
13918                                _errHandler.sync(this);
13919                                switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
13920                                case 1:
13921                                        {
13922                                        setState(1594);
13923                                        parameters();
13924                                        }
13925                                        break;
13926                                }
13927                                }
13928                                break;
13929                        default:
13930                                throw new NoViableAltException(this);
13931                        }
13932                        }
13933                }
13934                catch (RecognitionException re) {
13935                        _localctx.exception = re;
13936                        _errHandler.reportError(this, re);
13937                        _errHandler.recover(this, re);
13938                }
13939                finally {
13940                        exitRule();
13941                }
13942                return _localctx;
13943        }
13944
13945        public static class ParametersContext extends ParserRuleContext {
13946                public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); }
13947                public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); }
13948                public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); }
13949                public TerminalNode ARGUMENT(int i) {
13950                        return getToken(JavadocParser.ARGUMENT, i);
13951                }
13952                public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); }
13953                public TerminalNode COMMA(int i) {
13954                        return getToken(JavadocParser.COMMA, i);
13955                }
13956                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13957                public TerminalNode WS(int i) {
13958                        return getToken(JavadocParser.WS, i);
13959                }
13960                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13961                public TerminalNode NEWLINE(int i) {
13962                        return getToken(JavadocParser.NEWLINE, i);
13963                }
13964                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13965                public TerminalNode LEADING_ASTERISK(int i) {
13966                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13967                }
13968                public ParametersContext(ParserRuleContext parent, int invokingState) {
13969                        super(parent, invokingState);
13970                }
13971                @Override public int getRuleIndex() { return RULE_parameters; }
13972                @Override
13973                public void enterRule(ParseTreeListener listener) {
13974                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this);
13975                }
13976                @Override
13977                public void exitRule(ParseTreeListener listener) {
13978                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this);
13979                }
13980                @Override
13981                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13982                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this);
13983                        else return visitor.visitChildren(this);
13984                }
13985        }
13986
13987        public final ParametersContext parameters() throws RecognitionException {
13988                ParametersContext _localctx = new ParametersContext(_ctx, getState());
13989                enterRule(_localctx, 140, RULE_parameters);
13990                int _la;
13991                try {
13992                        enterOuterAlt(_localctx, 1);
13993                        {
13994                        setState(1599);
13995                        match(LEFT_BRACE);
13996                        setState(1603);
13997                        _errHandler.sync(this);
13998                        _la = _input.LA(1);
13999                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) {
14000                                {
14001                                {
14002                                setState(1600);
14003                                _la = _input.LA(1);
14004                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) {
14005                                _errHandler.recoverInline(this);
14006                                } else {
14007                                        consume();
14008                                }
14009                                }
14010                                }
14011                                setState(1605);
14012                                _errHandler.sync(this);
14013                                _la = _input.LA(1);
14014                        }
14015                        setState(1606);
14016                        match(RIGHT_BRACE);
14017                        }
14018                }
14019                catch (RecognitionException re) {
14020                        _localctx.exception = re;
14021                        _errHandler.reportError(this, re);
14022                        _errHandler.recover(this, re);
14023                }
14024                finally {
14025                        exitRule();
14026                }
14027                return _localctx;
14028        }
14029
14030        public static class JavadocTagContext extends ParserRuleContext {
14031                public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); }
14032                public DescriptionContext description() {
14033                        return getRuleContext(DescriptionContext.class,0);
14034                }
14035                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14036                public TerminalNode WS(int i) {
14037                        return getToken(JavadocParser.WS, i);
14038                }
14039                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14040                public TerminalNode NEWLINE(int i) {
14041                        return getToken(JavadocParser.NEWLINE, i);
14042                }
14043                public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); }
14044                public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); }
14045                public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); }
14046                public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); }
14047                public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); }
14048                public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); }
14049                public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); }
14050                public ReferenceContext reference() {
14051                        return getRuleContext(ReferenceContext.class,0);
14052                }
14053                public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); }
14054                public TerminalNode STRING(int i) {
14055                        return getToken(JavadocParser.STRING, i);
14056                }
14057                public List<HtmlElementContext> htmlElement() {
14058                        return getRuleContexts(HtmlElementContext.class);
14059                }
14060                public HtmlElementContext htmlElement(int i) {
14061                        return getRuleContext(HtmlElementContext.class,i);
14062                }
14063                public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); }
14064                public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); }
14065                public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); }
14066                public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); }
14067                public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); }
14068                public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); }
14069                public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); }
14070                public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); }
14071                public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); }
14072                public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); }
14073                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14074                public JavadocTagContext(ParserRuleContext parent, int invokingState) {
14075                        super(parent, invokingState);
14076                }
14077                @Override public int getRuleIndex() { return RULE_javadocTag; }
14078                @Override
14079                public void enterRule(ParseTreeListener listener) {
14080                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this);
14081                }
14082                @Override
14083                public void exitRule(ParseTreeListener listener) {
14084                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this);
14085                }
14086                @Override
14087                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14088                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this);
14089                        else return visitor.visitChildren(this);
14090                }
14091        }
14092
14093        public final JavadocTagContext javadocTag() throws RecognitionException {
14094                JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState());
14095                enterRule(_localctx, 142, RULE_javadocTag);
14096                int _la;
14097                try {
14098                        int _alt;
14099                        setState(1802);
14100                        switch (_input.LA(1)) {
14101                        case AUTHOR_LITERAL:
14102                                enterOuterAlt(_localctx, 1);
14103                                {
14104                                setState(1608);
14105                                match(AUTHOR_LITERAL);
14106                                setState(1612);
14107                                _errHandler.sync(this);
14108                                _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14109                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14110                                        if ( _alt==1 ) {
14111                                                {
14112                                                {
14113                                                setState(1609);
14114                                                _la = _input.LA(1);
14115                                                if ( !(_la==WS || _la==NEWLINE) ) {
14116                                                _errHandler.recoverInline(this);
14117                                                } else {
14118                                                        consume();
14119                                                }
14120                                                }
14121                                                } 
14122                                        }
14123                                        setState(1614);
14124                                        _errHandler.sync(this);
14125                                        _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14126                                }
14127                                setState(1616);
14128                                _errHandler.sync(this);
14129                                switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
14130                                case 1:
14131                                        {
14132                                        setState(1615);
14133                                        description();
14134                                        }
14135                                        break;
14136                                }
14137                                }
14138                                break;
14139                        case DEPRECATED_LITERAL:
14140                                enterOuterAlt(_localctx, 2);
14141                                {
14142                                setState(1618);
14143                                match(DEPRECATED_LITERAL);
14144                                setState(1622);
14145                                _errHandler.sync(this);
14146                                _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14147                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14148                                        if ( _alt==1 ) {
14149                                                {
14150                                                {
14151                                                setState(1619);
14152                                                _la = _input.LA(1);
14153                                                if ( !(_la==WS || _la==NEWLINE) ) {
14154                                                _errHandler.recoverInline(this);
14155                                                } else {
14156                                                        consume();
14157                                                }
14158                                                }
14159                                                } 
14160                                        }
14161                                        setState(1624);
14162                                        _errHandler.sync(this);
14163                                        _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14164                                }
14165                                setState(1626);
14166                                _errHandler.sync(this);
14167                                switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
14168                                case 1:
14169                                        {
14170                                        setState(1625);
14171                                        description();
14172                                        }
14173                                        break;
14174                                }
14175                                }
14176                                break;
14177                        case EXCEPTION_LITERAL:
14178                                enterOuterAlt(_localctx, 3);
14179                                {
14180                                setState(1628);
14181                                match(EXCEPTION_LITERAL);
14182                                setState(1632);
14183                                _errHandler.sync(this);
14184                                _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14185                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14186                                        if ( _alt==1 ) {
14187                                                {
14188                                                {
14189                                                setState(1629);
14190                                                _la = _input.LA(1);
14191                                                if ( !(_la==WS || _la==NEWLINE) ) {
14192                                                _errHandler.recoverInline(this);
14193                                                } else {
14194                                                        consume();
14195                                                }
14196                                                }
14197                                                } 
14198                                        }
14199                                        setState(1634);
14200                                        _errHandler.sync(this);
14201                                        _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14202                                }
14203                                setState(1636);
14204                                _errHandler.sync(this);
14205                                switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
14206                                case 1:
14207                                        {
14208                                        setState(1635);
14209                                        match(CLASS_NAME);
14210                                        }
14211                                        break;
14212                                }
14213                                setState(1641);
14214                                _errHandler.sync(this);
14215                                _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14216                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14217                                        if ( _alt==1 ) {
14218                                                {
14219                                                {
14220                                                setState(1638);
14221                                                _la = _input.LA(1);
14222                                                if ( !(_la==WS || _la==NEWLINE) ) {
14223                                                _errHandler.recoverInline(this);
14224                                                } else {
14225                                                        consume();
14226                                                }
14227                                                }
14228                                                } 
14229                                        }
14230                                        setState(1643);
14231                                        _errHandler.sync(this);
14232                                        _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14233                                }
14234                                setState(1645);
14235                                _errHandler.sync(this);
14236                                switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
14237                                case 1:
14238                                        {
14239                                        setState(1644);
14240                                        description();
14241                                        }
14242                                        break;
14243                                }
14244                                }
14245                                break;
14246                        case PARAM_LITERAL:
14247                                enterOuterAlt(_localctx, 4);
14248                                {
14249                                setState(1647);
14250                                match(PARAM_LITERAL);
14251                                setState(1651);
14252                                _errHandler.sync(this);
14253                                _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14254                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14255                                        if ( _alt==1 ) {
14256                                                {
14257                                                {
14258                                                setState(1648);
14259                                                _la = _input.LA(1);
14260                                                if ( !(_la==WS || _la==NEWLINE) ) {
14261                                                _errHandler.recoverInline(this);
14262                                                } else {
14263                                                        consume();
14264                                                }
14265                                                }
14266                                                } 
14267                                        }
14268                                        setState(1653);
14269                                        _errHandler.sync(this);
14270                                        _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14271                                }
14272                                setState(1655);
14273                                _errHandler.sync(this);
14274                                switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
14275                                case 1:
14276                                        {
14277                                        setState(1654);
14278                                        match(PARAMETER_NAME);
14279                                        }
14280                                        break;
14281                                }
14282                                setState(1660);
14283                                _errHandler.sync(this);
14284                                _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14285                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14286                                        if ( _alt==1 ) {
14287                                                {
14288                                                {
14289                                                setState(1657);
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(1662);
14300                                        _errHandler.sync(this);
14301                                        _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14302                                }
14303                                setState(1664);
14304                                _errHandler.sync(this);
14305                                switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
14306                                case 1:
14307                                        {
14308                                        setState(1663);
14309                                        description();
14310                                        }
14311                                        break;
14312                                }
14313                                }
14314                                break;
14315                        case RETURN_LITERAL:
14316                                enterOuterAlt(_localctx, 5);
14317                                {
14318                                setState(1666);
14319                                match(RETURN_LITERAL);
14320                                setState(1670);
14321                                _errHandler.sync(this);
14322                                _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14323                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14324                                        if ( _alt==1 ) {
14325                                                {
14326                                                {
14327                                                setState(1667);
14328                                                _la = _input.LA(1);
14329                                                if ( !(_la==WS || _la==NEWLINE) ) {
14330                                                _errHandler.recoverInline(this);
14331                                                } else {
14332                                                        consume();
14333                                                }
14334                                                }
14335                                                } 
14336                                        }
14337                                        setState(1672);
14338                                        _errHandler.sync(this);
14339                                        _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14340                                }
14341                                setState(1674);
14342                                _errHandler.sync(this);
14343                                switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
14344                                case 1:
14345                                        {
14346                                        setState(1673);
14347                                        description();
14348                                        }
14349                                        break;
14350                                }
14351                                }
14352                                break;
14353                        case SEE_LITERAL:
14354                                enterOuterAlt(_localctx, 6);
14355                                {
14356                                setState(1676);
14357                                match(SEE_LITERAL);
14358                                setState(1680);
14359                                _errHandler.sync(this);
14360                                _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14361                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14362                                        if ( _alt==1 ) {
14363                                                {
14364                                                {
14365                                                setState(1677);
14366                                                _la = _input.LA(1);
14367                                                if ( !(_la==WS || _la==NEWLINE) ) {
14368                                                _errHandler.recoverInline(this);
14369                                                } else {
14370                                                        consume();
14371                                                }
14372                                                }
14373                                                } 
14374                                        }
14375                                        setState(1682);
14376                                        _errHandler.sync(this);
14377                                        _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14378                                }
14379                                setState(1684);
14380                                _errHandler.sync(this);
14381                                switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
14382                                case 1:
14383                                        {
14384                                        setState(1683);
14385                                        reference();
14386                                        }
14387                                        break;
14388                                }
14389                                setState(1690);
14390                                _errHandler.sync(this);
14391                                _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14392                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14393                                        if ( _alt==1 ) {
14394                                                {
14395                                                setState(1688);
14396                                                switch (_input.LA(1)) {
14397                                                case STRING:
14398                                                        {
14399                                                        setState(1686);
14400                                                        match(STRING);
14401                                                        }
14402                                                        break;
14403                                                case OPEN:
14404                                                        {
14405                                                        setState(1687);
14406                                                        htmlElement();
14407                                                        }
14408                                                        break;
14409                                                default:
14410                                                        throw new NoViableAltException(this);
14411                                                }
14412                                                } 
14413                                        }
14414                                        setState(1692);
14415                                        _errHandler.sync(this);
14416                                        _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14417                                }
14418                                setState(1696);
14419                                _errHandler.sync(this);
14420                                _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14421                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14422                                        if ( _alt==1 ) {
14423                                                {
14424                                                {
14425                                                setState(1693);
14426                                                _la = _input.LA(1);
14427                                                if ( !(_la==WS || _la==NEWLINE) ) {
14428                                                _errHandler.recoverInline(this);
14429                                                } else {
14430                                                        consume();
14431                                                }
14432                                                }
14433                                                } 
14434                                        }
14435                                        setState(1698);
14436                                        _errHandler.sync(this);
14437                                        _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14438                                }
14439                                setState(1700);
14440                                _errHandler.sync(this);
14441                                switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
14442                                case 1:
14443                                        {
14444                                        setState(1699);
14445                                        description();
14446                                        }
14447                                        break;
14448                                }
14449                                }
14450                                break;
14451                        case SERIAL_LITERAL:
14452                                enterOuterAlt(_localctx, 7);
14453                                {
14454                                setState(1702);
14455                                match(SERIAL_LITERAL);
14456                                setState(1706);
14457                                _errHandler.sync(this);
14458                                _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14459                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14460                                        if ( _alt==1 ) {
14461                                                {
14462                                                {
14463                                                setState(1703);
14464                                                _la = _input.LA(1);
14465                                                if ( !(_la==WS || _la==NEWLINE) ) {
14466                                                _errHandler.recoverInline(this);
14467                                                } else {
14468                                                        consume();
14469                                                }
14470                                                }
14471                                                } 
14472                                        }
14473                                        setState(1708);
14474                                        _errHandler.sync(this);
14475                                        _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14476                                }
14477                                setState(1710);
14478                                _errHandler.sync(this);
14479                                switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
14480                                case 1:
14481                                        {
14482                                        setState(1709);
14483                                        _la = _input.LA(1);
14484                                        if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) {
14485                                        _errHandler.recoverInline(this);
14486                                        } else {
14487                                                consume();
14488                                        }
14489                                        }
14490                                        break;
14491                                }
14492                                setState(1713);
14493                                _errHandler.sync(this);
14494                                switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
14495                                case 1:
14496                                        {
14497                                        setState(1712);
14498                                        description();
14499                                        }
14500                                        break;
14501                                }
14502                                }
14503                                break;
14504                        case SERIAL_DATA_LITERAL:
14505                                enterOuterAlt(_localctx, 8);
14506                                {
14507                                setState(1715);
14508                                match(SERIAL_DATA_LITERAL);
14509                                setState(1719);
14510                                _errHandler.sync(this);
14511                                _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14512                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14513                                        if ( _alt==1 ) {
14514                                                {
14515                                                {
14516                                                setState(1716);
14517                                                _la = _input.LA(1);
14518                                                if ( !(_la==WS || _la==NEWLINE) ) {
14519                                                _errHandler.recoverInline(this);
14520                                                } else {
14521                                                        consume();
14522                                                }
14523                                                }
14524                                                } 
14525                                        }
14526                                        setState(1721);
14527                                        _errHandler.sync(this);
14528                                        _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14529                                }
14530                                setState(1723);
14531                                _errHandler.sync(this);
14532                                switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
14533                                case 1:
14534                                        {
14535                                        setState(1722);
14536                                        description();
14537                                        }
14538                                        break;
14539                                }
14540                                }
14541                                break;
14542                        case SERIAL_FIELD_LITERAL:
14543                                enterOuterAlt(_localctx, 9);
14544                                {
14545                                setState(1725);
14546                                match(SERIAL_FIELD_LITERAL);
14547                                setState(1729);
14548                                _errHandler.sync(this);
14549                                _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14550                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14551                                        if ( _alt==1 ) {
14552                                                {
14553                                                {
14554                                                setState(1726);
14555                                                _la = _input.LA(1);
14556                                                if ( !(_la==WS || _la==NEWLINE) ) {
14557                                                _errHandler.recoverInline(this);
14558                                                } else {
14559                                                        consume();
14560                                                }
14561                                                }
14562                                                } 
14563                                        }
14564                                        setState(1731);
14565                                        _errHandler.sync(this);
14566                                        _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14567                                }
14568                                setState(1733);
14569                                _errHandler.sync(this);
14570                                switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
14571                                case 1:
14572                                        {
14573                                        setState(1732);
14574                                        match(FIELD_NAME);
14575                                        }
14576                                        break;
14577                                }
14578                                setState(1738);
14579                                _errHandler.sync(this);
14580                                _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14581                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14582                                        if ( _alt==1 ) {
14583                                                {
14584                                                {
14585                                                setState(1735);
14586                                                _la = _input.LA(1);
14587                                                if ( !(_la==WS || _la==NEWLINE) ) {
14588                                                _errHandler.recoverInline(this);
14589                                                } else {
14590                                                        consume();
14591                                                }
14592                                                }
14593                                                } 
14594                                        }
14595                                        setState(1740);
14596                                        _errHandler.sync(this);
14597                                        _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14598                                }
14599                                setState(1742);
14600                                _errHandler.sync(this);
14601                                switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
14602                                case 1:
14603                                        {
14604                                        setState(1741);
14605                                        match(FIELD_TYPE);
14606                                        }
14607                                        break;
14608                                }
14609                                setState(1747);
14610                                _errHandler.sync(this);
14611                                _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14612                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14613                                        if ( _alt==1 ) {
14614                                                {
14615                                                {
14616                                                setState(1744);
14617                                                _la = _input.LA(1);
14618                                                if ( !(_la==WS || _la==NEWLINE) ) {
14619                                                _errHandler.recoverInline(this);
14620                                                } else {
14621                                                        consume();
14622                                                }
14623                                                }
14624                                                } 
14625                                        }
14626                                        setState(1749);
14627                                        _errHandler.sync(this);
14628                                        _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14629                                }
14630                                setState(1751);
14631                                _errHandler.sync(this);
14632                                switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
14633                                case 1:
14634                                        {
14635                                        setState(1750);
14636                                        description();
14637                                        }
14638                                        break;
14639                                }
14640                                }
14641                                break;
14642                        case SINCE_LITERAL:
14643                                enterOuterAlt(_localctx, 10);
14644                                {
14645                                setState(1753);
14646                                match(SINCE_LITERAL);
14647                                setState(1757);
14648                                _errHandler.sync(this);
14649                                _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14650                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14651                                        if ( _alt==1 ) {
14652                                                {
14653                                                {
14654                                                setState(1754);
14655                                                _la = _input.LA(1);
14656                                                if ( !(_la==WS || _la==NEWLINE) ) {
14657                                                _errHandler.recoverInline(this);
14658                                                } else {
14659                                                        consume();
14660                                                }
14661                                                }
14662                                                } 
14663                                        }
14664                                        setState(1759);
14665                                        _errHandler.sync(this);
14666                                        _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14667                                }
14668                                setState(1761);
14669                                _errHandler.sync(this);
14670                                switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
14671                                case 1:
14672                                        {
14673                                        setState(1760);
14674                                        description();
14675                                        }
14676                                        break;
14677                                }
14678                                }
14679                                break;
14680                        case THROWS_LITERAL:
14681                                enterOuterAlt(_localctx, 11);
14682                                {
14683                                setState(1763);
14684                                match(THROWS_LITERAL);
14685                                setState(1767);
14686                                _errHandler.sync(this);
14687                                _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14688                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14689                                        if ( _alt==1 ) {
14690                                                {
14691                                                {
14692                                                setState(1764);
14693                                                _la = _input.LA(1);
14694                                                if ( !(_la==WS || _la==NEWLINE) ) {
14695                                                _errHandler.recoverInline(this);
14696                                                } else {
14697                                                        consume();
14698                                                }
14699                                                }
14700                                                } 
14701                                        }
14702                                        setState(1769);
14703                                        _errHandler.sync(this);
14704                                        _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14705                                }
14706                                setState(1771);
14707                                _errHandler.sync(this);
14708                                switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
14709                                case 1:
14710                                        {
14711                                        setState(1770);
14712                                        match(CLASS_NAME);
14713                                        }
14714                                        break;
14715                                }
14716                                setState(1776);
14717                                _errHandler.sync(this);
14718                                _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14719                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14720                                        if ( _alt==1 ) {
14721                                                {
14722                                                {
14723                                                setState(1773);
14724                                                _la = _input.LA(1);
14725                                                if ( !(_la==WS || _la==NEWLINE) ) {
14726                                                _errHandler.recoverInline(this);
14727                                                } else {
14728                                                        consume();
14729                                                }
14730                                                }
14731                                                } 
14732                                        }
14733                                        setState(1778);
14734                                        _errHandler.sync(this);
14735                                        _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14736                                }
14737                                setState(1780);
14738                                _errHandler.sync(this);
14739                                switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
14740                                case 1:
14741                                        {
14742                                        setState(1779);
14743                                        description();
14744                                        }
14745                                        break;
14746                                }
14747                                }
14748                                break;
14749                        case VERSION_LITERAL:
14750                                enterOuterAlt(_localctx, 12);
14751                                {
14752                                setState(1782);
14753                                match(VERSION_LITERAL);
14754                                setState(1786);
14755                                _errHandler.sync(this);
14756                                _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14757                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14758                                        if ( _alt==1 ) {
14759                                                {
14760                                                {
14761                                                setState(1783);
14762                                                _la = _input.LA(1);
14763                                                if ( !(_la==WS || _la==NEWLINE) ) {
14764                                                _errHandler.recoverInline(this);
14765                                                } else {
14766                                                        consume();
14767                                                }
14768                                                }
14769                                                } 
14770                                        }
14771                                        setState(1788);
14772                                        _errHandler.sync(this);
14773                                        _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14774                                }
14775                                setState(1790);
14776                                _errHandler.sync(this);
14777                                switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
14778                                case 1:
14779                                        {
14780                                        setState(1789);
14781                                        description();
14782                                        }
14783                                        break;
14784                                }
14785                                }
14786                                break;
14787                        case CUSTOM_NAME:
14788                                enterOuterAlt(_localctx, 13);
14789                                {
14790                                setState(1792);
14791                                match(CUSTOM_NAME);
14792                                setState(1796);
14793                                _errHandler.sync(this);
14794                                _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14795                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14796                                        if ( _alt==1 ) {
14797                                                {
14798                                                {
14799                                                setState(1793);
14800                                                _la = _input.LA(1);
14801                                                if ( !(_la==WS || _la==NEWLINE) ) {
14802                                                _errHandler.recoverInline(this);
14803                                                } else {
14804                                                        consume();
14805                                                }
14806                                                }
14807                                                } 
14808                                        }
14809                                        setState(1798);
14810                                        _errHandler.sync(this);
14811                                        _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14812                                }
14813                                setState(1800);
14814                                _errHandler.sync(this);
14815                                switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
14816                                case 1:
14817                                        {
14818                                        setState(1799);
14819                                        description();
14820                                        }
14821                                        break;
14822                                }
14823                                }
14824                                break;
14825                        default:
14826                                throw new NoViableAltException(this);
14827                        }
14828                }
14829                catch (RecognitionException re) {
14830                        _localctx.exception = re;
14831                        _errHandler.reportError(this, re);
14832                        _errHandler.recover(this, re);
14833                }
14834                finally {
14835                        exitRule();
14836                }
14837                return _localctx;
14838        }
14839
14840        public static class JavadocInlineTagContext extends ParserRuleContext {
14841                public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); }
14842                public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); }
14843                public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); }
14844                public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); }
14845                public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); }
14846                public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); }
14847                public ReferenceContext reference() {
14848                        return getRuleContext(ReferenceContext.class,0);
14849                }
14850                public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); }
14851                public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); }
14852                public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); }
14853                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14854                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14855                public TerminalNode WS(int i) {
14856                        return getToken(JavadocParser.WS, i);
14857                }
14858                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14859                public TerminalNode NEWLINE(int i) {
14860                        return getToken(JavadocParser.NEWLINE, i);
14861                }
14862                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14863                public TerminalNode LEADING_ASTERISK(int i) {
14864                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14865                }
14866                public List<TextContext> text() {
14867                        return getRuleContexts(TextContext.class);
14868                }
14869                public TextContext text(int i) {
14870                        return getRuleContext(TextContext.class,i);
14871                }
14872                public DescriptionContext description() {
14873                        return getRuleContext(DescriptionContext.class,0);
14874                }
14875                public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) {
14876                        super(parent, invokingState);
14877                }
14878                @Override public int getRuleIndex() { return RULE_javadocInlineTag; }
14879                @Override
14880                public void enterRule(ParseTreeListener listener) {
14881                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this);
14882                }
14883                @Override
14884                public void exitRule(ParseTreeListener listener) {
14885                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this);
14886                }
14887                @Override
14888                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14889                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this);
14890                        else return visitor.visitChildren(this);
14891                }
14892        }
14893
14894        public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException {
14895                JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState());
14896                enterRule(_localctx, 144, RULE_javadocInlineTag);
14897                int _la;
14898                try {
14899                        int _alt;
14900                        enterOuterAlt(_localctx, 1);
14901                        {
14902                        setState(1804);
14903                        match(JAVADOC_INLINE_TAG_START);
14904                        setState(1881);
14905                        switch (_input.LA(1)) {
14906                        case CODE_LITERAL:
14907                                {
14908                                setState(1805);
14909                                match(CODE_LITERAL);
14910                                setState(1812);
14911                                _errHandler.sync(this);
14912                                _la = _input.LA(1);
14913                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
14914                                        {
14915                                        setState(1810);
14916                                        _errHandler.sync(this);
14917                                        switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
14918                                        case 1:
14919                                                {
14920                                                setState(1806);
14921                                                match(WS);
14922                                                }
14923                                                break;
14924                                        case 2:
14925                                                {
14926                                                setState(1807);
14927                                                match(NEWLINE);
14928                                                }
14929                                                break;
14930                                        case 3:
14931                                                {
14932                                                setState(1808);
14933                                                match(LEADING_ASTERISK);
14934                                                }
14935                                                break;
14936                                        case 4:
14937                                                {
14938                                                setState(1809);
14939                                                text();
14940                                                }
14941                                                break;
14942                                        }
14943                                        }
14944                                        setState(1814);
14945                                        _errHandler.sync(this);
14946                                        _la = _input.LA(1);
14947                                }
14948                                }
14949                                break;
14950                        case DOC_ROOT_LITERAL:
14951                                {
14952                                setState(1815);
14953                                match(DOC_ROOT_LITERAL);
14954                                setState(1819);
14955                                _errHandler.sync(this);
14956                                _la = _input.LA(1);
14957                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14958                                        {
14959                                        {
14960                                        setState(1816);
14961                                        _la = _input.LA(1);
14962                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14963                                        _errHandler.recoverInline(this);
14964                                        } else {
14965                                                consume();
14966                                        }
14967                                        }
14968                                        }
14969                                        setState(1821);
14970                                        _errHandler.sync(this);
14971                                        _la = _input.LA(1);
14972                                }
14973                                }
14974                                break;
14975                        case INHERIT_DOC_LITERAL:
14976                                {
14977                                setState(1822);
14978                                match(INHERIT_DOC_LITERAL);
14979                                setState(1826);
14980                                _errHandler.sync(this);
14981                                _la = _input.LA(1);
14982                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14983                                        {
14984                                        {
14985                                        setState(1823);
14986                                        _la = _input.LA(1);
14987                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14988                                        _errHandler.recoverInline(this);
14989                                        } else {
14990                                                consume();
14991                                        }
14992                                        }
14993                                        }
14994                                        setState(1828);
14995                                        _errHandler.sync(this);
14996                                        _la = _input.LA(1);
14997                                }
14998                                }
14999                                break;
15000                        case LINK_LITERAL:
15001                                {
15002                                setState(1829);
15003                                match(LINK_LITERAL);
15004                                setState(1833);
15005                                _errHandler.sync(this);
15006                                _la = _input.LA(1);
15007                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15008                                        {
15009                                        {
15010                                        setState(1830);
15011                                        _la = _input.LA(1);
15012                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15013                                        _errHandler.recoverInline(this);
15014                                        } else {
15015                                                consume();
15016                                        }
15017                                        }
15018                                        }
15019                                        setState(1835);
15020                                        _errHandler.sync(this);
15021                                        _la = _input.LA(1);
15022                                }
15023                                setState(1836);
15024                                reference();
15025                                setState(1838);
15026                                _errHandler.sync(this);
15027                                switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
15028                                case 1:
15029                                        {
15030                                        setState(1837);
15031                                        description();
15032                                        }
15033                                        break;
15034                                }
15035                                }
15036                                break;
15037                        case LINKPLAIN_LITERAL:
15038                                {
15039                                setState(1840);
15040                                match(LINKPLAIN_LITERAL);
15041                                setState(1844);
15042                                _errHandler.sync(this);
15043                                _la = _input.LA(1);
15044                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15045                                        {
15046                                        {
15047                                        setState(1841);
15048                                        _la = _input.LA(1);
15049                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15050                                        _errHandler.recoverInline(this);
15051                                        } else {
15052                                                consume();
15053                                        }
15054                                        }
15055                                        }
15056                                        setState(1846);
15057                                        _errHandler.sync(this);
15058                                        _la = _input.LA(1);
15059                                }
15060                                setState(1847);
15061                                reference();
15062                                setState(1849);
15063                                _errHandler.sync(this);
15064                                switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
15065                                case 1:
15066                                        {
15067                                        setState(1848);
15068                                        description();
15069                                        }
15070                                        break;
15071                                }
15072                                }
15073                                break;
15074                        case LITERAL_LITERAL:
15075                                {
15076                                setState(1851);
15077                                match(LITERAL_LITERAL);
15078                                setState(1858);
15079                                _errHandler.sync(this);
15080                                _la = _input.LA(1);
15081                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15082                                        {
15083                                        setState(1856);
15084                                        _errHandler.sync(this);
15085                                        switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
15086                                        case 1:
15087                                                {
15088                                                setState(1852);
15089                                                match(WS);
15090                                                }
15091                                                break;
15092                                        case 2:
15093                                                {
15094                                                setState(1853);
15095                                                match(NEWLINE);
15096                                                }
15097                                                break;
15098                                        case 3:
15099                                                {
15100                                                setState(1854);
15101                                                match(LEADING_ASTERISK);
15102                                                }
15103                                                break;
15104                                        case 4:
15105                                                {
15106                                                setState(1855);
15107                                                text();
15108                                                }
15109                                                break;
15110                                        }
15111                                        }
15112                                        setState(1860);
15113                                        _errHandler.sync(this);
15114                                        _la = _input.LA(1);
15115                                }
15116                                }
15117                                break;
15118                        case VALUE_LITERAL:
15119                                {
15120                                setState(1861);
15121                                match(VALUE_LITERAL);
15122                                setState(1865);
15123                                _errHandler.sync(this);
15124                                _la = _input.LA(1);
15125                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15126                                        {
15127                                        {
15128                                        setState(1862);
15129                                        _la = _input.LA(1);
15130                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15131                                        _errHandler.recoverInline(this);
15132                                        } else {
15133                                                consume();
15134                                        }
15135                                        }
15136                                        }
15137                                        setState(1867);
15138                                        _errHandler.sync(this);
15139                                        _la = _input.LA(1);
15140                                }
15141                                setState(1869);
15142                                _la = _input.LA(1);
15143                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) {
15144                                        {
15145                                        setState(1868);
15146                                        reference();
15147                                        }
15148                                }
15149
15150                                }
15151                                break;
15152                        case CUSTOM_NAME:
15153                                {
15154                                setState(1871);
15155                                match(CUSTOM_NAME);
15156                                setState(1875);
15157                                _errHandler.sync(this);
15158                                _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15159                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
15160                                        if ( _alt==1 ) {
15161                                                {
15162                                                {
15163                                                setState(1872);
15164                                                _la = _input.LA(1);
15165                                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15166                                                _errHandler.recoverInline(this);
15167                                                } else {
15168                                                        consume();
15169                                                }
15170                                                }
15171                                                } 
15172                                        }
15173                                        setState(1877);
15174                                        _errHandler.sync(this);
15175                                        _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15176                                }
15177                                setState(1879);
15178                                _errHandler.sync(this);
15179                                switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
15180                                case 1:
15181                                        {
15182                                        setState(1878);
15183                                        description();
15184                                        }
15185                                        break;
15186                                }
15187                                }
15188                                break;
15189                        default:
15190                                throw new NoViableAltException(this);
15191                        }
15192                        setState(1883);
15193                        match(JAVADOC_INLINE_TAG_END);
15194                        }
15195                }
15196                catch (RecognitionException re) {
15197                        _localctx.exception = re;
15198                        _errHandler.reportError(this, re);
15199                        _errHandler.recover(this, re);
15200                }
15201                finally {
15202                        exitRule();
15203                }
15204                return _localctx;
15205        }
15206
15207        public static class HtmlCommentContext extends ParserRuleContext {
15208                public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); }
15209                public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); }
15210                public List<TextContext> text() {
15211                        return getRuleContexts(TextContext.class);
15212                }
15213                public TextContext text(int i) {
15214                        return getRuleContext(TextContext.class,i);
15215                }
15216                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15217                public TerminalNode NEWLINE(int i) {
15218                        return getToken(JavadocParser.NEWLINE, i);
15219                }
15220                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15221                public TerminalNode LEADING_ASTERISK(int i) {
15222                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15223                }
15224                public HtmlCommentContext(ParserRuleContext parent, int invokingState) {
15225                        super(parent, invokingState);
15226                }
15227                @Override public int getRuleIndex() { return RULE_htmlComment; }
15228                @Override
15229                public void enterRule(ParseTreeListener listener) {
15230                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this);
15231                }
15232                @Override
15233                public void exitRule(ParseTreeListener listener) {
15234                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this);
15235                }
15236                @Override
15237                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15238                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this);
15239                        else return visitor.visitChildren(this);
15240                }
15241        }
15242
15243        public final HtmlCommentContext htmlComment() throws RecognitionException {
15244                HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState());
15245                enterRule(_localctx, 146, RULE_htmlComment);
15246                int _la;
15247                try {
15248                        enterOuterAlt(_localctx, 1);
15249                        {
15250                        setState(1885);
15251                        match(HTML_COMMENT_START);
15252                        setState(1891);
15253                        _errHandler.sync(this);
15254                        _la = _input.LA(1);
15255                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15256                                {
15257                                setState(1889);
15258                                switch (_input.LA(1)) {
15259                                case WS:
15260                                case CHAR:
15261                                        {
15262                                        setState(1886);
15263                                        text();
15264                                        }
15265                                        break;
15266                                case NEWLINE:
15267                                        {
15268                                        setState(1887);
15269                                        match(NEWLINE);
15270                                        }
15271                                        break;
15272                                case LEADING_ASTERISK:
15273                                        {
15274                                        setState(1888);
15275                                        match(LEADING_ASTERISK);
15276                                        }
15277                                        break;
15278                                default:
15279                                        throw new NoViableAltException(this);
15280                                }
15281                                }
15282                                setState(1893);
15283                                _errHandler.sync(this);
15284                                _la = _input.LA(1);
15285                        }
15286                        setState(1894);
15287                        match(HTML_COMMENT_END);
15288                        }
15289                }
15290                catch (RecognitionException re) {
15291                        _localctx.exception = re;
15292                        _errHandler.reportError(this, re);
15293                        _errHandler.recover(this, re);
15294                }
15295                finally {
15296                        exitRule();
15297                }
15298                return _localctx;
15299        }
15300
15301        public static class TextContext extends ParserRuleContext {
15302                public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); }
15303                public TerminalNode CHAR(int i) {
15304                        return getToken(JavadocParser.CHAR, i);
15305                }
15306                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15307                public TerminalNode WS(int i) {
15308                        return getToken(JavadocParser.WS, i);
15309                }
15310                public TextContext(ParserRuleContext parent, int invokingState) {
15311                        super(parent, invokingState);
15312                }
15313                @Override public int getRuleIndex() { return RULE_text; }
15314                @Override
15315                public void enterRule(ParseTreeListener listener) {
15316                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this);
15317                }
15318                @Override
15319                public void exitRule(ParseTreeListener listener) {
15320                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this);
15321                }
15322                @Override
15323                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15324                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this);
15325                        else return visitor.visitChildren(this);
15326                }
15327        }
15328
15329        public final TextContext text() throws RecognitionException {
15330                TextContext _localctx = new TextContext(_ctx, getState());
15331                enterRule(_localctx, 148, RULE_text);
15332                int _la;
15333                try {
15334                        int _alt;
15335                        enterOuterAlt(_localctx, 1);
15336                        {
15337                        setState(1898); 
15338                        _errHandler.sync(this);
15339                        _alt = 1;
15340                        do {
15341                                switch (_alt) {
15342                                case 1:
15343                                        {
15344                                        {
15345                                        setState(1896);
15346                                        _la = _input.LA(1);
15347                                        if ( !(_la==WS || _la==CHAR) ) {
15348                                        _errHandler.recoverInline(this);
15349                                        } else {
15350                                                consume();
15351                                        }
15352
15353                                          _la = _input.LA(1);
15354                                          if ((_la != WS) && (_la != CHAR)) return _localctx;
15355                                          else if (_alt == 1) continue;
15356                                         
15357                                        }
15358                                        }
15359                                        break;
15360                                default:
15361                                        throw new NoViableAltException(this);
15362                                }
15363                                setState(1900); 
15364                                _errHandler.sync(this);
15365                                _alt = getInterpreter().adaptivePredict(_input,194,_ctx);
15366                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15367                        }
15368                }
15369                catch (RecognitionException re) {
15370                        _localctx.exception = re;
15371                        _errHandler.reportError(this, re);
15372                        _errHandler.recover(this, re);
15373                }
15374                finally {
15375                        exitRule();
15376                }
15377                return _localctx;
15378        }
15379
15380        public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
15381                switch (ruleIndex) {
15382                case 0:
15383                        return javadoc_sempred((JavadocContext)_localctx, predIndex);
15384                case 5:
15385                        return htmlTag_sempred((HtmlTagContext)_localctx, predIndex);
15386                case 8:
15387                        return paragraph_sempred((ParagraphContext)_localctx, predIndex);
15388                case 11:
15389                        return li_sempred((LiContext)_localctx, predIndex);
15390                case 14:
15391                        return tr_sempred((TrContext)_localctx, predIndex);
15392                case 17:
15393                        return td_sempred((TdContext)_localctx, predIndex);
15394                case 20:
15395                        return th_sempred((ThContext)_localctx, predIndex);
15396                case 23:
15397                        return body_sempred((BodyContext)_localctx, predIndex);
15398                case 26:
15399                        return colgroup_sempred((ColgroupContext)_localctx, predIndex);
15400                case 29:
15401                        return dd_sempred((DdContext)_localctx, predIndex);
15402                case 32:
15403                        return dt_sempred((DtContext)_localctx, predIndex);
15404                case 35:
15405                        return head_sempred((HeadContext)_localctx, predIndex);
15406                case 38:
15407                        return html_sempred((HtmlContext)_localctx, predIndex);
15408                case 41:
15409                        return option_sempred((OptionContext)_localctx, predIndex);
15410                case 44:
15411                        return tbody_sempred((TbodyContext)_localctx, predIndex);
15412                case 47:
15413                        return tfoot_sempred((TfootContext)_localctx, predIndex);
15414                case 50:
15415                        return thead_sempred((TheadContext)_localctx, predIndex);
15416                case 68:
15417                        return description_sempred((DescriptionContext)_localctx, predIndex);
15418                }
15419                return true;
15420        }
15421        private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) {
15422                switch (predIndex) {
15423                case 0:
15424                        return !isNextJavadocTag();
15425                }
15426                return true;
15427        }
15428        private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) {
15429                switch (predIndex) {
15430                case 1:
15431                        return !isNextJavadocTag();
15432                case 2:
15433                        return !isNextJavadocTag();
15434                }
15435                return true;
15436        }
15437        private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) {
15438                switch (predIndex) {
15439                case 3:
15440                        return !isNextJavadocTag();
15441                }
15442                return true;
15443        }
15444        private boolean li_sempred(LiContext _localctx, int predIndex) {
15445                switch (predIndex) {
15446                case 4:
15447                        return !isNextJavadocTag();
15448                }
15449                return true;
15450        }
15451        private boolean tr_sempred(TrContext _localctx, int predIndex) {
15452                switch (predIndex) {
15453                case 5:
15454                        return !isNextJavadocTag();
15455                }
15456                return true;
15457        }
15458        private boolean td_sempred(TdContext _localctx, int predIndex) {
15459                switch (predIndex) {
15460                case 6:
15461                        return !isNextJavadocTag();
15462                }
15463                return true;
15464        }
15465        private boolean th_sempred(ThContext _localctx, int predIndex) {
15466                switch (predIndex) {
15467                case 7:
15468                        return !isNextJavadocTag();
15469                }
15470                return true;
15471        }
15472        private boolean body_sempred(BodyContext _localctx, int predIndex) {
15473                switch (predIndex) {
15474                case 8:
15475                        return !isNextJavadocTag();
15476                }
15477                return true;
15478        }
15479        private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) {
15480                switch (predIndex) {
15481                case 9:
15482                        return !isNextJavadocTag();
15483                }
15484                return true;
15485        }
15486        private boolean dd_sempred(DdContext _localctx, int predIndex) {
15487                switch (predIndex) {
15488                case 10:
15489                        return !isNextJavadocTag();
15490                }
15491                return true;
15492        }
15493        private boolean dt_sempred(DtContext _localctx, int predIndex) {
15494                switch (predIndex) {
15495                case 11:
15496                        return !isNextJavadocTag();
15497                }
15498                return true;
15499        }
15500        private boolean head_sempred(HeadContext _localctx, int predIndex) {
15501                switch (predIndex) {
15502                case 12:
15503                        return !isNextJavadocTag();
15504                }
15505                return true;
15506        }
15507        private boolean html_sempred(HtmlContext _localctx, int predIndex) {
15508                switch (predIndex) {
15509                case 13:
15510                        return !isNextJavadocTag();
15511                }
15512                return true;
15513        }
15514        private boolean option_sempred(OptionContext _localctx, int predIndex) {
15515                switch (predIndex) {
15516                case 14:
15517                        return !isNextJavadocTag();
15518                }
15519                return true;
15520        }
15521        private boolean tbody_sempred(TbodyContext _localctx, int predIndex) {
15522                switch (predIndex) {
15523                case 15:
15524                        return !isNextJavadocTag();
15525                }
15526                return true;
15527        }
15528        private boolean tfoot_sempred(TfootContext _localctx, int predIndex) {
15529                switch (predIndex) {
15530                case 16:
15531                        return !isNextJavadocTag();
15532                }
15533                return true;
15534        }
15535        private boolean thead_sempred(TheadContext _localctx, int predIndex) {
15536                switch (predIndex) {
15537                case 17:
15538                        return !isNextJavadocTag();
15539                }
15540                return true;
15541        }
15542        private boolean description_sempred(DescriptionContext _localctx, int predIndex) {
15543                switch (predIndex) {
15544                case 18:
15545                        return !isNextJavadocTag();
15546                }
15547                return true;
15548        }
15549
15550        public static final String _serializedATN =
15551                "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u0771\4\2\t\2\4"+
15552                "\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"+
15553                "\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"+
15554                "\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"+
15555                "\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!"+
15556                "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
15557                ",\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"+
15558                "\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="+
15559                "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
15560                "\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"+
15561                "\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"+
15562                "\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"+
15563                "\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"+
15564                "\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"+
15565                "\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"+
15566                "\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"+
15567                "\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"+
15568                "\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"+
15569                "\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"+
15570                "\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"+
15571                "\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"+
15572                "\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"+
15573                "\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"+
15574                "\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"+
15575                "\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"+
15576                "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+
15577                "\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"+
15578                "\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"+
15579                "\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"+
15580                "\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"+
15581                "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+
15582                "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+
15583                "\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"+
15584                "\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"+
15585                "\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"+
15586                "\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"+
15587                "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+
15588                "\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"+
15589                "\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"+
15590                "\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"+
15591                "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+
15592                "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+
15593                "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+
15594                "\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"+
15595                "\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"+
15596                "\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"+
15597                "\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"+
15598                "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+
15599                "\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"+
15600                "\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"+
15601                "\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"+
15602                "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+
15603                "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+
15604                "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+
15605                "\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"+
15606                "\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"+
15607                "\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"+
15608                "\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"+
15609                "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+
15610                "\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"+
15611                "\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"+
15612                "\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"+
15613                "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+
15614                " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+
15615                "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
15616                "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
15617                "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+
15618                "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+
15619                "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15620                "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
15621                "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+
15622                "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+
15623                "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15624                "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+
15625                "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+
15626                ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+
15627                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+
15628                "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+
15629                "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+
15630                "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15631                "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
15632                "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+
15633                "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+
15634                "\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"+
15635                "\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"+
15636                "\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"+
15637                "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+
15638                "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+
15639                "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+
15640                "\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"+
15641                "\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"+
15642                "\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"+
15643                "\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"+
15644                "\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"+
15645                "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+
15646                "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+
15647                "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+
15648                "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+
15649                "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+
15650                "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+
15651                "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+
15652                "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+
15653                "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+
15654                "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+
15655                "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+
15656                "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+
15657                "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+
15658                "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+
15659                "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+
15660                "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+
15661                "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+
15662                "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+
15663                "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+
15664                "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+
15665                "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+
15666                "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+
15667                "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+
15668                "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+
15669                "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+
15670                "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+
15671                "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+
15672                "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+
15673                "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+
15674                "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+
15675                "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+
15676                "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+
15677                "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+
15678                "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+
15679                "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+
15680                "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+
15681                "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+
15682                "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+
15683                "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+
15684                "\6\b\b\4\2=KYY\3\29:\3\2LX\4\2\37\37!!\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b"+
15685                "\3\2\30\31\4\2\6\6\32\32\u0a88\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7"+
15686                "\3\2\2\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2"+
15687                "\2\2\20\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2"+
15688                "\2\30\u0191\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2"+
15689                " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+
15690                "\2\2\2*\u0260\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62"+
15691                "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+
15692                "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+
15693                "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+
15694                "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+
15695                "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+
15696                "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+
15697                "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+
15698                "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+
15699                "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+
15700                "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+
15701                "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+
15702                "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+
15703                "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+
15704                "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+
15705                "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+
15706                "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+
15707                "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
15708                "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+
15709                "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+
15710                "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+
15711                "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+
15712                "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
15713                "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+
15714                "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+
15715                "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+
15716                "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+
15717                "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+
15718                "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+
15719                "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+
15720                "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+
15721                "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+
15722                "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+
15723                "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+
15724                "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+
15725                "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+
15726                "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+
15727                "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+
15728                "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+
15729                "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+
15730                "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+
15731                "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+
15732                "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+
15733                "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+
15734                "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+
15735                "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+
15736                "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+
15737                "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+
15738                "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+
15739                "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+
15740                "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+
15741                "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+
15742                "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+
15743                "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+
15744                "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+
15745                "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+
15746                "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+
15747                "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
15748                "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+
15749                "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+
15750                "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+
15751                "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+
15752                "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+
15753                "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+
15754                "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+
15755                "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+
15756                "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+
15757                "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+
15758                "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+
15759                "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+
15760                "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
15761                "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+
15762                "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+
15763                "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+
15764                "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+
15765                "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+
15766                "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+
15767                "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+
15768                "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+
15769                "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+
15770                "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+
15771                "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+
15772                "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
15773                "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+
15774                "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+
15775                "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+
15776                "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+
15777                "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+
15778                "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+
15779                "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+
15780                "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+
15781                "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+
15782                "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+
15783                "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+
15784                "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+
15785                "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+
15786                "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+
15787                "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+
15788                "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+
15789                "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+
15790                "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+
15791                "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+
15792                "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+
15793                "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+
15794                "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+
15795                "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
15796                "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+
15797                "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+
15798                "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+
15799                "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+
15800                "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+
15801                "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+
15802                "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+
15803                "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
15804                "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+
15805                "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+
15806                "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+
15807                "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+
15808                "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+
15809                "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+
15810                "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+
15811                "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+
15812                "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+
15813                "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+
15814                "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+
15815                "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+
15816                "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+
15817                "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+
15818                "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+
15819                "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+
15820                "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+
15821                "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+
15822                "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+
15823                "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+
15824                "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+
15825                "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+
15826                "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+
15827                "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+
15828                "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+
15829                "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+
15830                "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+
15831                "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+
15832                "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+
15833                "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+
15834                "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+
15835                "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+
15836                "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+
15837                "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
15838                "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
15839                "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+
15840                "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+
15841                "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+
15842                "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+
15843                "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+
15844                "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+
15845                "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+
15846                "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+
15847                "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+
15848                "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+
15849                "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+
15850                "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+
15851                "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+
15852                "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+
15853                "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+
15854                "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+
15855                "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+
15856                "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+
15857                "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+
15858                "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+
15859                "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+
15860                "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+
15861                "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+
15862                "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+
15863                "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+
15864                "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+
15865                "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+
15866                "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+
15867                "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+
15868                "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+
15869                "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+
15870                "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+
15871                "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+
15872                "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+
15873                "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+
15874                "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+
15875                "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+
15876                "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+
15877                "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+
15878                "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+
15879                "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+
15880                "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+
15881                "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+
15882                "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+
15883                "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+
15884                "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+
15885                "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+
15886                "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+
15887                "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+
15888                "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+
15889                "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+
15890                "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+
15891                "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+
15892                "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+
15893                "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+
15894                "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+
15895                "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+
15896                "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
15897                "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+
15898                "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+
15899                "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+
15900                "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+
15901                "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+
15902                "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+
15903                "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+
15904                "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+
15905                "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+
15906                "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+
15907                "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+
15908                "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+
15909                "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+
15910                "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+
15911                "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+
15912                "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+
15913                "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+
15914                "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+
15915                "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+
15916                "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+
15917                "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+
15918                "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+
15919                "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+
15920                "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+
15921                "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+
15922                "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
15923                "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+
15924                "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+
15925                "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+
15926                "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+
15927                "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+
15928                "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+
15929                "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+
15930                "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+
15931                "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+
15932                "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+
15933                "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+
15934                "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+
15935                "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+
15936                "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+
15937                "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+
15938                "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+
15939                "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+
15940                ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+
15941                "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+
15942                "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+
15943                "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+
15944                "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+
15945                "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+
15946                "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+
15947                "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+
15948                "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+
15949                "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+
15950                "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+
15951                "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+
15952                "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+
15953                "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+
15954                "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+
15955                "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+
15956                "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+
15957                "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+
15958                "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+
15959                "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+
15960                "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+
15961                "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+
15962                "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+
15963                "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+
15964                "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+
15965                "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+
15966                "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+
15967                "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+
15968                "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+
15969                "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+
15970                "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+
15971                "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+
15972                "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+
15973                "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+
15974                "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+
15975                "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+
15976                "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+
15977                "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+
15978                "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+
15979                "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+
15980                "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+
15981                "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+
15982                "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+
15983                "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+
15984                "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
15985                "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+
15986                "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+
15987                "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+
15988                "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+
15989                "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+
15990                "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+
15991                "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+
15992                "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+
15993                "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+
15994                ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+
15995                "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+
15996                "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+
15997                "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+
15998                "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+
15999                "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+
16000                "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+
16001                "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+
16002                "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+
16003                "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+
16004                "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+
16005                "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+
16006                "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+
16007                "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+
16008                "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+
16009                "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+
16010                "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+
16011                "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+
16012                "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+
16013                "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+
16014                "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+
16015                "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+
16016                "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+
16017                "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+
16018                "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+
16019                "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+
16020                "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
16021                "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+
16022                "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+
16023                "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+
16024                "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+
16025                "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+
16026                "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+
16027                "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+
16028                "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+
16029                "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+
16030                "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+
16031                "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+
16032                "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+
16033                "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+
16034                "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+
16035                "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+
16036                "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+
16037                "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+
16038                "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+
16039                "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+
16040                "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+
16041                "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+
16042                "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+
16043                "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+
16044                "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+
16045                "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+
16046                "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+
16047                "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+
16048                "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+
16049                "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+
16050                "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+
16051                "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+
16052                "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+
16053                "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+
16054                "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+
16055                "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+
16056                "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+
16057                "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+
16058                "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+
16059                "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+
16060                "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+
16061                "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+
16062                "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+
16063                "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+
16064                "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+
16065                "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+
16066                "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+
16067                "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+
16068                "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+
16069                "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+
16070                "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+
16071                "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+
16072                "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+
16073                "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+
16074                "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+
16075                "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+
16076                "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+
16077                "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+
16078                "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+
16079                "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+
16080                "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+
16081                "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
16082                "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+
16083                "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+
16084                "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+
16085                "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+
16086                "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+
16087                "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+
16088                "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+
16089                "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+
16090                "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+
16091                "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+
16092                "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+
16093                "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+
16094                "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+
16095                "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+
16096                "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+
16097                "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+
16098                "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+
16099                "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+
16100                "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+
16101                "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+
16102                "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+
16103                "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+
16104                "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+
16105                "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+
16106                "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+
16107                "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+
16108                "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+
16109                "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+
16110                "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+
16111                "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+
16112                "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+
16113                "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+
16114                "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+
16115                "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+
16116                "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+
16117                "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+
16118                "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+
16119                "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+
16120                "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+
16121                "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+
16122                "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+
16123                "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+
16124                "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+
16125                "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+
16126                "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+
16127                "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+
16128                "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+
16129                "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+
16130                "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+
16131                "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+
16132                "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+
16133                "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+
16134                "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+
16135                "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+
16136                "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+
16137                "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+
16138                "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+
16139                "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+
16140                "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+
16141                "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+
16142                "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+
16143                "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+
16144                "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+
16145                "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+
16146                "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+
16147                "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+
16148                "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+
16149                "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+
16150                "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+
16151                "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+
16152                "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+
16153                "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+
16154                "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+
16155                "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+
16156                "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+
16157                "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+
16158                "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+
16159                "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+
16160                "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+
16161                "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+
16162                "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+
16163                "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+
16164                "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+
16165                "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+
16166                "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+
16167                "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+
16168                "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+
16169                "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+
16170                "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+
16171                "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+
16172                "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+
16173                "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+
16174                "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+
16175                "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+
16176                "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+
16177                "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+
16178                "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+
16179                "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+
16180                "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+
16181                "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+
16182                "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+
16183                "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+
16184                "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+
16185                "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+
16186                "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+
16187                "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+
16188                "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+
16189                "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+
16190                "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+
16191                "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+
16192                "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+
16193                "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+
16194                "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+
16195                "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+
16196                "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+
16197                "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+
16198                "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+
16199                "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+
16200                "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+
16201                "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+
16202                "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+
16203                "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+
16204                "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+
16205                "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+
16206                "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+
16207                "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+
16208                "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+
16209                "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+
16210                "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+
16211                "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+
16212                "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+
16213                "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+
16214                "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+
16215                "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+
16216                "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+
16217                "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+
16218                "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+
16219                "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+
16220                "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+
16221                "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+
16222                "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+
16223                "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+
16224                "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+
16225                "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+
16226                "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+
16227                "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+
16228                "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+
16229                "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+
16230                "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+
16231                "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+
16232                "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
16233                "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+
16234                "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+
16235                "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+
16236                "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+
16237                "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+
16238                "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+
16239                "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+
16240                "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+
16241                "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+
16242                "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+
16243                "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+
16244                "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+
16245                "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+
16246                "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+
16247                "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+
16248                "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+
16249                "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+
16250                "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+
16251                "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+
16252                "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+
16253                "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+
16254                "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+
16255                "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+
16256                "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+
16257                "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+
16258                "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+
16259                "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+
16260                "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+
16261                "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+
16262                "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+
16263                "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+
16264                "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+
16265                "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+
16266                "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+
16267                "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+
16268                "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+
16269                "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+
16270                "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+
16271                "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+
16272                "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+
16273                "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+
16274                "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+
16275                "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+
16276                "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+
16277                "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+
16278                "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+
16279                "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+
16280                "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+
16281                "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+
16282                "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+
16283                "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+
16284                "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+
16285                "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+
16286                "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+
16287                "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+
16288                "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+
16289                "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+
16290                "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+
16291                "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+
16292                "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+
16293                "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+
16294                "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+
16295                "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+
16296                "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+
16297                "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+
16298                "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+
16299                "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+
16300                "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+
16301                "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
16302                "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+
16303                "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+
16304                "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+
16305                "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+
16306                "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+
16307                "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+
16308                "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+
16309                "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+
16310                "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+
16311                "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+
16312                "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+
16313                "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+
16314                "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+
16315                "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+
16316                "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+
16317                "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+
16318                "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+
16319                "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+
16320                "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+
16321                "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+
16322                "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+
16323                "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+
16324                "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+
16325                "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+
16326                "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+
16327                "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+
16328                "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+
16329                "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+
16330                "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+
16331                "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+
16332                "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+
16333                "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+
16334                "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+
16335                "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+
16336                "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+
16337                "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+
16338                "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+
16339                "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+
16340                "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+
16341                "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+
16342                "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+
16343                "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+
16344                "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+
16345                "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+
16346                "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+
16347                "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+
16348                "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+
16349                "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+
16350                "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+
16351                "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+
16352                "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+
16353                "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+
16354                "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+
16355                "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+
16356                "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+
16357                "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+
16358                "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+
16359                "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+
16360                "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+
16361                "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+
16362                "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+
16363                "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+
16364                "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
16365                "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+
16366                "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+
16367                "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+
16368                "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+
16369                "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+
16370                "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+
16371                "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+
16372                "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+
16373                "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+
16374                "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+
16375                "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+
16376                "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+
16377                "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+
16378                "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+
16379                "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+
16380                "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+
16381                "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+
16382                "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+
16383                "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+
16384                "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+
16385                "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+
16386                "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+
16387                "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+
16388                "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+
16389                "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+
16390                "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+
16391                "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+
16392                "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+
16393                "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+
16394                "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+
16395                "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+
16396                "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+
16397                "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+
16398                "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+
16399                "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+
16400                "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+
16401                "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+
16402                "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+
16403                "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+
16404                "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+
16405                "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+
16406                "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+
16407                "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+
16408                "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+
16409                "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+
16410                "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+
16411                "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+
16412                "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+
16413                "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+
16414                "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+
16415                "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+
16416                "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+
16417                "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+
16418                "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+
16419                "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+
16420                "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+
16421                "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+
16422                "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+
16423                "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+
16424                "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+
16425                "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+
16426                "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+
16427                "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
16428                "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+
16429                "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+
16430                "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+
16431                "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+
16432                "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+
16433                "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+
16434                "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+
16435                "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+
16436                "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+
16437                "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+
16438                "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+
16439                "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+
16440                "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+
16441                "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+
16442                "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+
16443                "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+
16444                "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+
16445                "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+
16446                "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+
16447                "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+
16448                "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+
16449                "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+
16450                "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+
16451                "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+
16452                "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+
16453                "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+
16454                "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+
16455                "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+
16456                "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+
16457                "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e";
16458        public static final ATN _ATN =
16459                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
16460        static {
16461                _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
16462                for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
16463                        _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
16464                }
16465        }
16466}