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, BASEFRONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 
037                COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 
038                INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 
039                META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, HTML_TAG_NAME=87, Char11=88, 
040                ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91;
041        public static final int
042                RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 
043                RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 
044                RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 
045                RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 
046                RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 
047                RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 
048                RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 
049                RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 
050                RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 
051                RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 
052                RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 
053                RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 
054                RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 
055                RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 
056                RULE_baseTag = 54, RULE_basefrontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 
057                RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 
058                RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 
059                RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 
060                RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 
061                RULE_htmlComment = 73, RULE_text = 74;
062        public static final String[] ruleNames = {
063                "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 
064                "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 
065                "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 
066                "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 
067                "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 
068                "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 
069                "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 
070                "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 
071                "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 
072                "singletonTag", "areaTag", "baseTag", "basefrontTag", "brTag", "colTag", 
073                "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 
074                "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 
075                "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text"
076        };
077
078        private static final String[] _LITERAL_NAMES = {
079                null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 
080                null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 
081                null, "'@version'", null, null, null, "'include'", "'exclude'", null, 
082                null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 
083                "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 
084                "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 
085                "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 
086                null, null, null, null, null, null, null, null, null, null, null, null, 
087                null, null, null, null, null, null, null, null, null, null, "'-->'"
088        };
089        private static final String[] _SYMBOLIC_NAMES = {
090                null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 
091                "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 
092                "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 
093                "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 
094                "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 
095                "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", 
096                "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 
097                "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 
098                "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 
099                "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 
100                "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "SLASH", "EQUALS", 
101                "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 
102                "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 
103                "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 
104                "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 
105                "BASE_HTML_TAG_NAME", "BASEFRONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 
106                "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 
107                "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 
108                "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END"
109        };
110        public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
111
112        /**
113         * @deprecated Use {@link #VOCABULARY} instead.
114         */
115        @Deprecated
116        public static final String[] tokenNames;
117        static {
118                tokenNames = new String[_SYMBOLIC_NAMES.length];
119                for (int i = 0; i < tokenNames.length; i++) {
120                        tokenNames[i] = VOCABULARY.getLiteralName(i);
121                        if (tokenNames[i] == null) {
122                                tokenNames[i] = VOCABULARY.getSymbolicName(i);
123                        }
124
125                        if (tokenNames[i] == null) {
126                                tokenNames[i] = "<INVALID>";
127                        }
128                }
129        }
130
131        @Override
132        @Deprecated
133        public String[] getTokenNames() {
134                return tokenNames;
135        }
136
137        @Override
138
139        public Vocabulary getVocabulary() {
140                return VOCABULARY;
141        }
142
143        @Override
144        public String getGrammarFileName() { return "JavadocParser.g4"; }
145
146        @Override
147        public String[] getRuleNames() { return ruleNames; }
148
149        @Override
150        public String getSerializedATN() { return _serializedATN; }
151
152        @Override
153        public ATN getATN() { return _ATN; }
154
155
156            boolean isNextJavadocTag() {
157                int token1 = _input.LA(2);
158                int token2 = _input.LA(3);
159                return isJavadocTag(token1)
160                    || (token1 == WS && isJavadocTag(token2));
161            }
162
163            boolean isJavadocTag(int type) {
164                switch(type) {
165                    case AUTHOR_LITERAL:
166                    case DEPRECATED_LITERAL:
167                    case EXCEPTION_LITERAL:
168                    case PARAM_LITERAL:
169                    case RETURN_LITERAL:
170                    case SEE_LITERAL:
171                    case SERIAL_LITERAL:
172                    case SERIAL_FIELD_LITERAL:
173                    case SERIAL_DATA_LITERAL:
174                    case SINCE_LITERAL:
175                    case THROWS_LITERAL:
176                    case VERSION_LITERAL:
177                    case CUSTOM_NAME:
178                        return true;
179                    default:
180                        return false;
181                }
182            }
183
184              boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) {
185                    String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
186                    String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase();
187                    System.out.println(openTag + " - " + closeTag);
188                    return openTag.equals(closeTag);
189              }
190
191        public JavadocParser(TokenStream input) {
192                super(input);
193                _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
194        }
195        public static class JavadocContext extends ParserRuleContext {
196                public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
197                public List<HtmlElementContext> htmlElement() {
198                        return getRuleContexts(HtmlElementContext.class);
199                }
200                public HtmlElementContext htmlElement(int i) {
201                        return getRuleContext(HtmlElementContext.class,i);
202                }
203                public List<HtmlCommentContext> htmlComment() {
204                        return getRuleContexts(HtmlCommentContext.class);
205                }
206                public HtmlCommentContext htmlComment(int i) {
207                        return getRuleContext(HtmlCommentContext.class,i);
208                }
209                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
210                public TerminalNode CDATA(int i) {
211                        return getToken(JavadocParser.CDATA, i);
212                }
213                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
214                public TerminalNode NEWLINE(int i) {
215                        return getToken(JavadocParser.NEWLINE, i);
216                }
217                public List<TextContext> text() {
218                        return getRuleContexts(TextContext.class);
219                }
220                public TextContext text(int i) {
221                        return getRuleContext(TextContext.class,i);
222                }
223                public List<JavadocInlineTagContext> javadocInlineTag() {
224                        return getRuleContexts(JavadocInlineTagContext.class);
225                }
226                public JavadocInlineTagContext javadocInlineTag(int i) {
227                        return getRuleContext(JavadocInlineTagContext.class,i);
228                }
229                public List<JavadocTagContext> javadocTag() {
230                        return getRuleContexts(JavadocTagContext.class);
231                }
232                public JavadocTagContext javadocTag(int i) {
233                        return getRuleContext(JavadocTagContext.class,i);
234                }
235                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
236                public TerminalNode LEADING_ASTERISK(int i) {
237                        return getToken(JavadocParser.LEADING_ASTERISK, i);
238                }
239                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
240                public TerminalNode WS(int i) {
241                        return getToken(JavadocParser.WS, i);
242                }
243                public JavadocContext(ParserRuleContext parent, int invokingState) {
244                        super(parent, invokingState);
245                }
246                @Override public int getRuleIndex() { return RULE_javadoc; }
247                @Override
248                public void enterRule(ParseTreeListener listener) {
249                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this);
250                }
251                @Override
252                public void exitRule(ParseTreeListener listener) {
253                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this);
254                }
255                @Override
256                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
257                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this);
258                        else return visitor.visitChildren(this);
259                }
260        }
261
262        public final JavadocContext javadoc() throws RecognitionException {
263                JavadocContext _localctx = new JavadocContext(_ctx, getState());
264                enterRule(_localctx, 0, RULE_javadoc);
265                int _la;
266                try {
267                        int _alt;
268                        enterOuterAlt(_localctx, 1);
269                        {
270                        setState(160);
271                        _errHandler.sync(this);
272                        _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
273                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
274                                if ( _alt==1 ) {
275                                        {
276                                        setState(158);
277                                        _errHandler.sync(this);
278                                        switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
279                                        case 1:
280                                                {
281                                                setState(150);
282                                                htmlElement();
283                                                }
284                                                break;
285                                        case 2:
286                                                {
287                                                {
288                                                setState(151);
289                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
290                                                setState(152);
291                                                match(LEADING_ASTERISK);
292                                                }
293                                                }
294                                                break;
295                                        case 3:
296                                                {
297                                                setState(153);
298                                                htmlComment();
299                                                }
300                                                break;
301                                        case 4:
302                                                {
303                                                setState(154);
304                                                match(CDATA);
305                                                }
306                                                break;
307                                        case 5:
308                                                {
309                                                setState(155);
310                                                match(NEWLINE);
311                                                }
312                                                break;
313                                        case 6:
314                                                {
315                                                setState(156);
316                                                text();
317                                                }
318                                                break;
319                                        case 7:
320                                                {
321                                                setState(157);
322                                                javadocInlineTag();
323                                                }
324                                                break;
325                                        }
326                                        } 
327                                }
328                                setState(162);
329                                _errHandler.sync(this);
330                                _alt = getInterpreter().adaptivePredict(_input,1,_ctx);
331                        }
332                        setState(175);
333                        _errHandler.sync(this);
334                        _la = _input.LA(1);
335                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << AUTHOR_LITERAL) | (1L << DEPRECATED_LITERAL) | (1L << EXCEPTION_LITERAL) | (1L << PARAM_LITERAL) | (1L << RETURN_LITERAL) | (1L << SEE_LITERAL) | (1L << SERIAL_LITERAL) | (1L << SERIAL_FIELD_LITERAL) | (1L << SERIAL_DATA_LITERAL) | (1L << SINCE_LITERAL) | (1L << THROWS_LITERAL) | (1L << VERSION_LITERAL) | (1L << CUSTOM_NAME))) != 0)) {
336                                {
337                                {
338                                setState(164);
339                                _la = _input.LA(1);
340                                if (_la==LEADING_ASTERISK) {
341                                        {
342                                        setState(163);
343                                        match(LEADING_ASTERISK);
344                                        }
345                                }
346
347                                setState(169);
348                                _errHandler.sync(this);
349                                _la = _input.LA(1);
350                                while (_la==WS) {
351                                        {
352                                        {
353                                        setState(166);
354                                        match(WS);
355                                        }
356                                        }
357                                        setState(171);
358                                        _errHandler.sync(this);
359                                        _la = _input.LA(1);
360                                }
361                                setState(172);
362                                javadocTag();
363                                }
364                                }
365                                setState(177);
366                                _errHandler.sync(this);
367                                _la = _input.LA(1);
368                        }
369                        setState(178);
370                        match(EOF);
371                        }
372                }
373                catch (RecognitionException re) {
374                        _localctx.exception = re;
375                        _errHandler.reportError(this, re);
376                        _errHandler.recover(this, re);
377                }
378                finally {
379                        exitRule();
380                }
381                return _localctx;
382        }
383
384        public static class HtmlElementContext extends ParserRuleContext {
385                public HtmlTagContext htmlTag() {
386                        return getRuleContext(HtmlTagContext.class,0);
387                }
388                public SingletonElementContext singletonElement() {
389                        return getRuleContext(SingletonElementContext.class,0);
390                }
391                public ParagraphContext paragraph() {
392                        return getRuleContext(ParagraphContext.class,0);
393                }
394                public LiContext li() {
395                        return getRuleContext(LiContext.class,0);
396                }
397                public TrContext tr() {
398                        return getRuleContext(TrContext.class,0);
399                }
400                public TdContext td() {
401                        return getRuleContext(TdContext.class,0);
402                }
403                public ThContext th() {
404                        return getRuleContext(ThContext.class,0);
405                }
406                public BodyContext body() {
407                        return getRuleContext(BodyContext.class,0);
408                }
409                public ColgroupContext colgroup() {
410                        return getRuleContext(ColgroupContext.class,0);
411                }
412                public DdContext dd() {
413                        return getRuleContext(DdContext.class,0);
414                }
415                public DtContext dt() {
416                        return getRuleContext(DtContext.class,0);
417                }
418                public HeadContext head() {
419                        return getRuleContext(HeadContext.class,0);
420                }
421                public HtmlContext html() {
422                        return getRuleContext(HtmlContext.class,0);
423                }
424                public OptionContext option() {
425                        return getRuleContext(OptionContext.class,0);
426                }
427                public TbodyContext tbody() {
428                        return getRuleContext(TbodyContext.class,0);
429                }
430                public TheadContext thead() {
431                        return getRuleContext(TheadContext.class,0);
432                }
433                public TfootContext tfoot() {
434                        return getRuleContext(TfootContext.class,0);
435                }
436                public PTagOpenContext pTagOpen() {
437                        return getRuleContext(PTagOpenContext.class,0);
438                }
439                public LiTagOpenContext liTagOpen() {
440                        return getRuleContext(LiTagOpenContext.class,0);
441                }
442                public TrTagOpenContext trTagOpen() {
443                        return getRuleContext(TrTagOpenContext.class,0);
444                }
445                public TdTagOpenContext tdTagOpen() {
446                        return getRuleContext(TdTagOpenContext.class,0);
447                }
448                public ThTagOpenContext thTagOpen() {
449                        return getRuleContext(ThTagOpenContext.class,0);
450                }
451                public BodyTagOpenContext bodyTagOpen() {
452                        return getRuleContext(BodyTagOpenContext.class,0);
453                }
454                public ColgroupTagOpenContext colgroupTagOpen() {
455                        return getRuleContext(ColgroupTagOpenContext.class,0);
456                }
457                public DdTagOpenContext ddTagOpen() {
458                        return getRuleContext(DdTagOpenContext.class,0);
459                }
460                public DtTagOpenContext dtTagOpen() {
461                        return getRuleContext(DtTagOpenContext.class,0);
462                }
463                public HeadTagOpenContext headTagOpen() {
464                        return getRuleContext(HeadTagOpenContext.class,0);
465                }
466                public HtmlTagOpenContext htmlTagOpen() {
467                        return getRuleContext(HtmlTagOpenContext.class,0);
468                }
469                public OptionTagOpenContext optionTagOpen() {
470                        return getRuleContext(OptionTagOpenContext.class,0);
471                }
472                public TbodyTagOpenContext tbodyTagOpen() {
473                        return getRuleContext(TbodyTagOpenContext.class,0);
474                }
475                public TheadTagOpenContext theadTagOpen() {
476                        return getRuleContext(TheadTagOpenContext.class,0);
477                }
478                public TfootTagOpenContext tfootTagOpen() {
479                        return getRuleContext(TfootTagOpenContext.class,0);
480                }
481                public PTagCloseContext pTagClose() {
482                        return getRuleContext(PTagCloseContext.class,0);
483                }
484                public LiTagCloseContext liTagClose() {
485                        return getRuleContext(LiTagCloseContext.class,0);
486                }
487                public TrTagCloseContext trTagClose() {
488                        return getRuleContext(TrTagCloseContext.class,0);
489                }
490                public TdTagCloseContext tdTagClose() {
491                        return getRuleContext(TdTagCloseContext.class,0);
492                }
493                public ThTagCloseContext thTagClose() {
494                        return getRuleContext(ThTagCloseContext.class,0);
495                }
496                public BodyTagCloseContext bodyTagClose() {
497                        return getRuleContext(BodyTagCloseContext.class,0);
498                }
499                public ColgroupTagCloseContext colgroupTagClose() {
500                        return getRuleContext(ColgroupTagCloseContext.class,0);
501                }
502                public DdTagCloseContext ddTagClose() {
503                        return getRuleContext(DdTagCloseContext.class,0);
504                }
505                public DtTagCloseContext dtTagClose() {
506                        return getRuleContext(DtTagCloseContext.class,0);
507                }
508                public HeadTagCloseContext headTagClose() {
509                        return getRuleContext(HeadTagCloseContext.class,0);
510                }
511                public HtmlTagCloseContext htmlTagClose() {
512                        return getRuleContext(HtmlTagCloseContext.class,0);
513                }
514                public OptionTagCloseContext optionTagClose() {
515                        return getRuleContext(OptionTagCloseContext.class,0);
516                }
517                public TbodyTagCloseContext tbodyTagClose() {
518                        return getRuleContext(TbodyTagCloseContext.class,0);
519                }
520                public TheadTagCloseContext theadTagClose() {
521                        return getRuleContext(TheadTagCloseContext.class,0);
522                }
523                public TfootTagCloseContext tfootTagClose() {
524                        return getRuleContext(TfootTagCloseContext.class,0);
525                }
526                public HtmlElementContext(ParserRuleContext parent, int invokingState) {
527                        super(parent, invokingState);
528                }
529                @Override public int getRuleIndex() { return RULE_htmlElement; }
530                @Override
531                public void enterRule(ParseTreeListener listener) {
532                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this);
533                }
534                @Override
535                public void exitRule(ParseTreeListener listener) {
536                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this);
537                }
538                @Override
539                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
540                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this);
541                        else return visitor.visitChildren(this);
542                }
543        }
544
545        public final HtmlElementContext htmlElement() throws RecognitionException {
546                HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
547                enterRule(_localctx, 2, RULE_htmlElement);
548                try {
549                        setState(227);
550                        _errHandler.sync(this);
551                        switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
552                        case 1:
553                                enterOuterAlt(_localctx, 1);
554                                {
555                                setState(180);
556                                htmlTag();
557                                }
558                                break;
559                        case 2:
560                                enterOuterAlt(_localctx, 2);
561                                {
562                                setState(181);
563                                singletonElement();
564                                }
565                                break;
566                        case 3:
567                                enterOuterAlt(_localctx, 3);
568                                {
569                                setState(182);
570                                paragraph();
571                                }
572                                break;
573                        case 4:
574                                enterOuterAlt(_localctx, 4);
575                                {
576                                setState(183);
577                                li();
578                                }
579                                break;
580                        case 5:
581                                enterOuterAlt(_localctx, 5);
582                                {
583                                setState(184);
584                                tr();
585                                }
586                                break;
587                        case 6:
588                                enterOuterAlt(_localctx, 6);
589                                {
590                                setState(185);
591                                td();
592                                }
593                                break;
594                        case 7:
595                                enterOuterAlt(_localctx, 7);
596                                {
597                                setState(186);
598                                th();
599                                }
600                                break;
601                        case 8:
602                                enterOuterAlt(_localctx, 8);
603                                {
604                                setState(187);
605                                body();
606                                }
607                                break;
608                        case 9:
609                                enterOuterAlt(_localctx, 9);
610                                {
611                                setState(188);
612                                colgroup();
613                                }
614                                break;
615                        case 10:
616                                enterOuterAlt(_localctx, 10);
617                                {
618                                setState(189);
619                                dd();
620                                }
621                                break;
622                        case 11:
623                                enterOuterAlt(_localctx, 11);
624                                {
625                                setState(190);
626                                dt();
627                                }
628                                break;
629                        case 12:
630                                enterOuterAlt(_localctx, 12);
631                                {
632                                setState(191);
633                                head();
634                                }
635                                break;
636                        case 13:
637                                enterOuterAlt(_localctx, 13);
638                                {
639                                setState(192);
640                                html();
641                                }
642                                break;
643                        case 14:
644                                enterOuterAlt(_localctx, 14);
645                                {
646                                setState(193);
647                                option();
648                                }
649                                break;
650                        case 15:
651                                enterOuterAlt(_localctx, 15);
652                                {
653                                setState(194);
654                                tbody();
655                                }
656                                break;
657                        case 16:
658                                enterOuterAlt(_localctx, 16);
659                                {
660                                setState(195);
661                                thead();
662                                }
663                                break;
664                        case 17:
665                                enterOuterAlt(_localctx, 17);
666                                {
667                                setState(196);
668                                tfoot();
669                                }
670                                break;
671                        case 18:
672                                enterOuterAlt(_localctx, 18);
673                                {
674                                setState(197);
675                                pTagOpen();
676                                }
677                                break;
678                        case 19:
679                                enterOuterAlt(_localctx, 19);
680                                {
681                                setState(198);
682                                liTagOpen();
683                                }
684                                break;
685                        case 20:
686                                enterOuterAlt(_localctx, 20);
687                                {
688                                setState(199);
689                                trTagOpen();
690                                }
691                                break;
692                        case 21:
693                                enterOuterAlt(_localctx, 21);
694                                {
695                                setState(200);
696                                tdTagOpen();
697                                }
698                                break;
699                        case 22:
700                                enterOuterAlt(_localctx, 22);
701                                {
702                                setState(201);
703                                thTagOpen();
704                                }
705                                break;
706                        case 23:
707                                enterOuterAlt(_localctx, 23);
708                                {
709                                setState(202);
710                                bodyTagOpen();
711                                }
712                                break;
713                        case 24:
714                                enterOuterAlt(_localctx, 24);
715                                {
716                                setState(203);
717                                colgroupTagOpen();
718                                }
719                                break;
720                        case 25:
721                                enterOuterAlt(_localctx, 25);
722                                {
723                                setState(204);
724                                ddTagOpen();
725                                }
726                                break;
727                        case 26:
728                                enterOuterAlt(_localctx, 26);
729                                {
730                                setState(205);
731                                dtTagOpen();
732                                }
733                                break;
734                        case 27:
735                                enterOuterAlt(_localctx, 27);
736                                {
737                                setState(206);
738                                headTagOpen();
739                                }
740                                break;
741                        case 28:
742                                enterOuterAlt(_localctx, 28);
743                                {
744                                setState(207);
745                                htmlTagOpen();
746                                }
747                                break;
748                        case 29:
749                                enterOuterAlt(_localctx, 29);
750                                {
751                                setState(208);
752                                optionTagOpen();
753                                }
754                                break;
755                        case 30:
756                                enterOuterAlt(_localctx, 30);
757                                {
758                                setState(209);
759                                tbodyTagOpen();
760                                }
761                                break;
762                        case 31:
763                                enterOuterAlt(_localctx, 31);
764                                {
765                                setState(210);
766                                theadTagOpen();
767                                }
768                                break;
769                        case 32:
770                                enterOuterAlt(_localctx, 32);
771                                {
772                                setState(211);
773                                tfootTagOpen();
774                                }
775                                break;
776                        case 33:
777                                enterOuterAlt(_localctx, 33);
778                                {
779                                setState(212);
780                                pTagClose();
781                                }
782                                break;
783                        case 34:
784                                enterOuterAlt(_localctx, 34);
785                                {
786                                setState(213);
787                                liTagClose();
788                                }
789                                break;
790                        case 35:
791                                enterOuterAlt(_localctx, 35);
792                                {
793                                setState(214);
794                                trTagClose();
795                                }
796                                break;
797                        case 36:
798                                enterOuterAlt(_localctx, 36);
799                                {
800                                setState(215);
801                                tdTagClose();
802                                }
803                                break;
804                        case 37:
805                                enterOuterAlt(_localctx, 37);
806                                {
807                                setState(216);
808                                thTagClose();
809                                }
810                                break;
811                        case 38:
812                                enterOuterAlt(_localctx, 38);
813                                {
814                                setState(217);
815                                bodyTagClose();
816                                }
817                                break;
818                        case 39:
819                                enterOuterAlt(_localctx, 39);
820                                {
821                                setState(218);
822                                colgroupTagClose();
823                                }
824                                break;
825                        case 40:
826                                enterOuterAlt(_localctx, 40);
827                                {
828                                setState(219);
829                                ddTagClose();
830                                }
831                                break;
832                        case 41:
833                                enterOuterAlt(_localctx, 41);
834                                {
835                                setState(220);
836                                dtTagClose();
837                                }
838                                break;
839                        case 42:
840                                enterOuterAlt(_localctx, 42);
841                                {
842                                setState(221);
843                                headTagClose();
844                                }
845                                break;
846                        case 43:
847                                enterOuterAlt(_localctx, 43);
848                                {
849                                setState(222);
850                                htmlTagClose();
851                                }
852                                break;
853                        case 44:
854                                enterOuterAlt(_localctx, 44);
855                                {
856                                setState(223);
857                                optionTagClose();
858                                }
859                                break;
860                        case 45:
861                                enterOuterAlt(_localctx, 45);
862                                {
863                                setState(224);
864                                tbodyTagClose();
865                                }
866                                break;
867                        case 46:
868                                enterOuterAlt(_localctx, 46);
869                                {
870                                setState(225);
871                                theadTagClose();
872                                }
873                                break;
874                        case 47:
875                                enterOuterAlt(_localctx, 47);
876                                {
877                                setState(226);
878                                tfootTagClose();
879                                }
880                                break;
881                        }
882                }
883                catch (RecognitionException re) {
884                        _localctx.exception = re;
885                        _errHandler.reportError(this, re);
886                        _errHandler.recover(this, re);
887                }
888                finally {
889                        exitRule();
890                }
891                return _localctx;
892        }
893
894        public static class HtmlElementOpenContext extends ParserRuleContext {
895                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
896                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
897                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
898                public List<AttributeContext> attribute() {
899                        return getRuleContexts(AttributeContext.class);
900                }
901                public AttributeContext attribute(int i) {
902                        return getRuleContext(AttributeContext.class,i);
903                }
904                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
905                public TerminalNode NEWLINE(int i) {
906                        return getToken(JavadocParser.NEWLINE, i);
907                }
908                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
909                public TerminalNode LEADING_ASTERISK(int i) {
910                        return getToken(JavadocParser.LEADING_ASTERISK, i);
911                }
912                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
913                public TerminalNode WS(int i) {
914                        return getToken(JavadocParser.WS, i);
915                }
916                public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) {
917                        super(parent, invokingState);
918                }
919                @Override public int getRuleIndex() { return RULE_htmlElementOpen; }
920                @Override
921                public void enterRule(ParseTreeListener listener) {
922                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this);
923                }
924                @Override
925                public void exitRule(ParseTreeListener listener) {
926                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this);
927                }
928                @Override
929                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
930                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this);
931                        else return visitor.visitChildren(this);
932                }
933        }
934
935        public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException {
936                HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState());
937                enterRule(_localctx, 4, RULE_htmlElementOpen);
938                int _la;
939                try {
940                        enterOuterAlt(_localctx, 1);
941                        {
942                        setState(229);
943                        match(OPEN);
944                        setState(230);
945                        match(HTML_TAG_NAME);
946                        setState(237);
947                        _errHandler.sync(this);
948                        _la = _input.LA(1);
949                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
950                                {
951                                setState(235);
952                                switch (_input.LA(1)) {
953                                case HTML_TAG_NAME:
954                                        {
955                                        setState(231);
956                                        attribute();
957                                        }
958                                        break;
959                                case NEWLINE:
960                                        {
961                                        setState(232);
962                                        match(NEWLINE);
963                                        }
964                                        break;
965                                case LEADING_ASTERISK:
966                                        {
967                                        setState(233);
968                                        match(LEADING_ASTERISK);
969                                        }
970                                        break;
971                                case WS:
972                                        {
973                                        setState(234);
974                                        match(WS);
975                                        }
976                                        break;
977                                default:
978                                        throw new NoViableAltException(this);
979                                }
980                                }
981                                setState(239);
982                                _errHandler.sync(this);
983                                _la = _input.LA(1);
984                        }
985                        setState(240);
986                        match(CLOSE);
987                        }
988                }
989                catch (RecognitionException re) {
990                        _localctx.exception = re;
991                        _errHandler.reportError(this, re);
992                        _errHandler.recover(this, re);
993                }
994                finally {
995                        exitRule();
996                }
997                return _localctx;
998        }
999
1000        public static class HtmlElementCloseContext extends ParserRuleContext {
1001                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1002                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1003                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
1004                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1005                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1006                public TerminalNode NEWLINE(int i) {
1007                        return getToken(JavadocParser.NEWLINE, i);
1008                }
1009                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1010                public TerminalNode LEADING_ASTERISK(int i) {
1011                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1012                }
1013                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1014                public TerminalNode WS(int i) {
1015                        return getToken(JavadocParser.WS, i);
1016                }
1017                public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) {
1018                        super(parent, invokingState);
1019                }
1020                @Override public int getRuleIndex() { return RULE_htmlElementClose; }
1021                @Override
1022                public void enterRule(ParseTreeListener listener) {
1023                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this);
1024                }
1025                @Override
1026                public void exitRule(ParseTreeListener listener) {
1027                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this);
1028                }
1029                @Override
1030                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1031                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this);
1032                        else return visitor.visitChildren(this);
1033                }
1034        }
1035
1036        public final HtmlElementCloseContext htmlElementClose() throws RecognitionException {
1037                HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState());
1038                enterRule(_localctx, 6, RULE_htmlElementClose);
1039                int _la;
1040                try {
1041                        enterOuterAlt(_localctx, 1);
1042                        {
1043                        setState(242);
1044                        match(OPEN);
1045                        setState(243);
1046                        match(SLASH);
1047                        setState(244);
1048                        match(HTML_TAG_NAME);
1049                        setState(248);
1050                        _errHandler.sync(this);
1051                        _la = _input.LA(1);
1052                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1053                                {
1054                                {
1055                                setState(245);
1056                                _la = _input.LA(1);
1057                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1058                                _errHandler.recoverInline(this);
1059                                } else {
1060                                        consume();
1061                                }
1062                                }
1063                                }
1064                                setState(250);
1065                                _errHandler.sync(this);
1066                                _la = _input.LA(1);
1067                        }
1068                        setState(251);
1069                        match(CLOSE);
1070                        }
1071                }
1072                catch (RecognitionException re) {
1073                        _localctx.exception = re;
1074                        _errHandler.reportError(this, re);
1075                        _errHandler.recover(this, re);
1076                }
1077                finally {
1078                        exitRule();
1079                }
1080                return _localctx;
1081        }
1082
1083        public static class AttributeContext extends ParserRuleContext {
1084                public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); }
1085                public TerminalNode HTML_TAG_NAME(int i) {
1086                        return getToken(JavadocParser.HTML_TAG_NAME, i);
1087                }
1088                public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); }
1089                public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); }
1090                public TextContext text() {
1091                        return getRuleContext(TextContext.class,0);
1092                }
1093                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1094                public TerminalNode NEWLINE(int i) {
1095                        return getToken(JavadocParser.NEWLINE, i);
1096                }
1097                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1098                public TerminalNode LEADING_ASTERISK(int i) {
1099                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1100                }
1101                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1102                public TerminalNode WS(int i) {
1103                        return getToken(JavadocParser.WS, i);
1104                }
1105                public AttributeContext(ParserRuleContext parent, int invokingState) {
1106                        super(parent, invokingState);
1107                }
1108                @Override public int getRuleIndex() { return RULE_attribute; }
1109                @Override
1110                public void enterRule(ParseTreeListener listener) {
1111                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this);
1112                }
1113                @Override
1114                public void exitRule(ParseTreeListener listener) {
1115                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this);
1116                }
1117                @Override
1118                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1119                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this);
1120                        else return visitor.visitChildren(this);
1121                }
1122        }
1123
1124        public final AttributeContext attribute() throws RecognitionException {
1125                AttributeContext _localctx = new AttributeContext(_ctx, getState());
1126                enterRule(_localctx, 8, RULE_attribute);
1127                int _la;
1128                try {
1129                        int _alt;
1130                        enterOuterAlt(_localctx, 1);
1131                        {
1132                        setState(253);
1133                        match(HTML_TAG_NAME);
1134                        setState(257);
1135                        _errHandler.sync(this);
1136                        _la = _input.LA(1);
1137                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1138                                {
1139                                {
1140                                setState(254);
1141                                _la = _input.LA(1);
1142                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1143                                _errHandler.recoverInline(this);
1144                                } else {
1145                                        consume();
1146                                }
1147                                }
1148                                }
1149                                setState(259);
1150                                _errHandler.sync(this);
1151                                _la = _input.LA(1);
1152                        }
1153                        setState(260);
1154                        match(EQUALS);
1155                        setState(264);
1156                        _errHandler.sync(this);
1157                        _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1158                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1159                                if ( _alt==1 ) {
1160                                        {
1161                                        {
1162                                        setState(261);
1163                                        _la = _input.LA(1);
1164                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1165                                        _errHandler.recoverInline(this);
1166                                        } else {
1167                                                consume();
1168                                        }
1169                                        }
1170                                        } 
1171                                }
1172                                setState(266);
1173                                _errHandler.sync(this);
1174                                _alt = getInterpreter().adaptivePredict(_input,10,_ctx);
1175                        }
1176                        setState(270);
1177                        switch (_input.LA(1)) {
1178                        case ATTR_VALUE:
1179                                {
1180                                setState(267);
1181                                match(ATTR_VALUE);
1182                                }
1183                                break;
1184                        case WS:
1185                        case CHAR:
1186                                {
1187                                setState(268);
1188                                text();
1189                                }
1190                                break;
1191                        case HTML_TAG_NAME:
1192                                {
1193                                setState(269);
1194                                match(HTML_TAG_NAME);
1195                                }
1196                                break;
1197                        default:
1198                                throw new NoViableAltException(this);
1199                        }
1200                        }
1201                }
1202                catch (RecognitionException re) {
1203                        _localctx.exception = re;
1204                        _errHandler.reportError(this, re);
1205                        _errHandler.recover(this, re);
1206                }
1207                finally {
1208                        exitRule();
1209                }
1210                return _localctx;
1211        }
1212
1213        public static class HtmlTagContext extends ParserRuleContext {
1214                public HtmlElementOpenContext htmlElementOpen;
1215                public HtmlElementOpenContext htmlElementOpen() {
1216                        return getRuleContext(HtmlElementOpenContext.class,0);
1217                }
1218                public HtmlElementCloseContext htmlElementClose() {
1219                        return getRuleContext(HtmlElementCloseContext.class,0);
1220                }
1221                public List<HtmlElementContext> htmlElement() {
1222                        return getRuleContexts(HtmlElementContext.class);
1223                }
1224                public HtmlElementContext htmlElement(int i) {
1225                        return getRuleContext(HtmlElementContext.class,i);
1226                }
1227                public List<HtmlCommentContext> htmlComment() {
1228                        return getRuleContexts(HtmlCommentContext.class);
1229                }
1230                public HtmlCommentContext htmlComment(int i) {
1231                        return getRuleContext(HtmlCommentContext.class,i);
1232                }
1233                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1234                public TerminalNode CDATA(int i) {
1235                        return getToken(JavadocParser.CDATA, i);
1236                }
1237                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1238                public TerminalNode NEWLINE(int i) {
1239                        return getToken(JavadocParser.NEWLINE, i);
1240                }
1241                public List<TextContext> text() {
1242                        return getRuleContexts(TextContext.class);
1243                }
1244                public TextContext text(int i) {
1245                        return getRuleContext(TextContext.class,i);
1246                }
1247                public List<JavadocInlineTagContext> javadocInlineTag() {
1248                        return getRuleContexts(JavadocInlineTagContext.class);
1249                }
1250                public JavadocInlineTagContext javadocInlineTag(int i) {
1251                        return getRuleContext(JavadocInlineTagContext.class,i);
1252                }
1253                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1254                public TerminalNode LEADING_ASTERISK(int i) {
1255                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1256                }
1257                public HtmlTagContext(ParserRuleContext parent, int invokingState) {
1258                        super(parent, invokingState);
1259                }
1260                @Override public int getRuleIndex() { return RULE_htmlTag; }
1261                @Override
1262                public void enterRule(ParseTreeListener listener) {
1263                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this);
1264                }
1265                @Override
1266                public void exitRule(ParseTreeListener listener) {
1267                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this);
1268                }
1269                @Override
1270                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1271                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this);
1272                        else return visitor.visitChildren(this);
1273                }
1274        }
1275
1276        public final HtmlTagContext htmlTag() throws RecognitionException {
1277                HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState());
1278                enterRule(_localctx, 10, RULE_htmlTag);
1279                try {
1280                        int _alt;
1281                        setState(304);
1282                        _errHandler.sync(this);
1283                        switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
1284                        case 1:
1285                                enterOuterAlt(_localctx, 1);
1286                                {
1287                                setState(272);
1288                                htmlElementOpen();
1289                                setState(283);
1290                                _errHandler.sync(this);
1291                                _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1292                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1293                                        if ( _alt==1 ) {
1294                                                {
1295                                                setState(281);
1296                                                _errHandler.sync(this);
1297                                                switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
1298                                                case 1:
1299                                                        {
1300                                                        setState(273);
1301                                                        htmlElement();
1302                                                        }
1303                                                        break;
1304                                                case 2:
1305                                                        {
1306                                                        {
1307                                                        setState(274);
1308                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1309                                                        setState(275);
1310                                                        match(LEADING_ASTERISK);
1311                                                        }
1312                                                        }
1313                                                        break;
1314                                                case 3:
1315                                                        {
1316                                                        setState(276);
1317                                                        htmlComment();
1318                                                        }
1319                                                        break;
1320                                                case 4:
1321                                                        {
1322                                                        setState(277);
1323                                                        match(CDATA);
1324                                                        }
1325                                                        break;
1326                                                case 5:
1327                                                        {
1328                                                        setState(278);
1329                                                        match(NEWLINE);
1330                                                        }
1331                                                        break;
1332                                                case 6:
1333                                                        {
1334                                                        setState(279);
1335                                                        text();
1336                                                        }
1337                                                        break;
1338                                                case 7:
1339                                                        {
1340                                                        setState(280);
1341                                                        javadocInlineTag();
1342                                                        }
1343                                                        break;
1344                                                }
1345                                                } 
1346                                        }
1347                                        setState(285);
1348                                        _errHandler.sync(this);
1349                                        _alt = getInterpreter().adaptivePredict(_input,13,_ctx);
1350                                }
1351                                setState(286);
1352                                htmlElementClose();
1353                                }
1354                                break;
1355                        case 2:
1356                                enterOuterAlt(_localctx, 2);
1357                                {
1358                                setState(288);
1359                                ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen();
1360                                setState(299);
1361                                _errHandler.sync(this);
1362                                _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1363                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1364                                        if ( _alt==1 ) {
1365                                                {
1366                                                setState(297);
1367                                                _errHandler.sync(this);
1368                                                switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
1369                                                case 1:
1370                                                        {
1371                                                        setState(289);
1372                                                        htmlElement();
1373                                                        }
1374                                                        break;
1375                                                case 2:
1376                                                        {
1377                                                        {
1378                                                        setState(290);
1379                                                        if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
1380                                                        setState(291);
1381                                                        match(LEADING_ASTERISK);
1382                                                        }
1383                                                        }
1384                                                        break;
1385                                                case 3:
1386                                                        {
1387                                                        setState(292);
1388                                                        htmlComment();
1389                                                        }
1390                                                        break;
1391                                                case 4:
1392                                                        {
1393                                                        setState(293);
1394                                                        match(CDATA);
1395                                                        }
1396                                                        break;
1397                                                case 5:
1398                                                        {
1399                                                        setState(294);
1400                                                        match(NEWLINE);
1401                                                        }
1402                                                        break;
1403                                                case 6:
1404                                                        {
1405                                                        setState(295);
1406                                                        text();
1407                                                        }
1408                                                        break;
1409                                                case 7:
1410                                                        {
1411                                                        setState(296);
1412                                                        javadocInlineTag();
1413                                                        }
1414                                                        break;
1415                                                }
1416                                                } 
1417                                        }
1418                                        setState(301);
1419                                        _errHandler.sync(this);
1420                                        _alt = getInterpreter().adaptivePredict(_input,15,_ctx);
1421                                }
1422                                notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol(), "javadoc.missed.html.close", null);
1423                                }
1424                                break;
1425                        }
1426                }
1427                catch (RecognitionException re) {
1428                        _localctx.exception = re;
1429                        _errHandler.reportError(this, re);
1430                        _errHandler.recover(this, re);
1431                }
1432                finally {
1433                        exitRule();
1434                }
1435                return _localctx;
1436        }
1437
1438        public static class PTagOpenContext extends ParserRuleContext {
1439                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1440                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1441                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1442                public List<AttributeContext> attribute() {
1443                        return getRuleContexts(AttributeContext.class);
1444                }
1445                public AttributeContext attribute(int i) {
1446                        return getRuleContext(AttributeContext.class,i);
1447                }
1448                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1449                public TerminalNode NEWLINE(int i) {
1450                        return getToken(JavadocParser.NEWLINE, i);
1451                }
1452                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1453                public TerminalNode LEADING_ASTERISK(int i) {
1454                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1455                }
1456                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1457                public TerminalNode WS(int i) {
1458                        return getToken(JavadocParser.WS, i);
1459                }
1460                public PTagOpenContext(ParserRuleContext parent, int invokingState) {
1461                        super(parent, invokingState);
1462                }
1463                @Override public int getRuleIndex() { return RULE_pTagOpen; }
1464                @Override
1465                public void enterRule(ParseTreeListener listener) {
1466                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this);
1467                }
1468                @Override
1469                public void exitRule(ParseTreeListener listener) {
1470                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this);
1471                }
1472                @Override
1473                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1474                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this);
1475                        else return visitor.visitChildren(this);
1476                }
1477        }
1478
1479        public final PTagOpenContext pTagOpen() throws RecognitionException {
1480                PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState());
1481                enterRule(_localctx, 12, RULE_pTagOpen);
1482                int _la;
1483                try {
1484                        enterOuterAlt(_localctx, 1);
1485                        {
1486                        setState(306);
1487                        match(OPEN);
1488                        setState(307);
1489                        match(P_HTML_TAG_NAME);
1490                        setState(314);
1491                        _errHandler.sync(this);
1492                        _la = _input.LA(1);
1493                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
1494                                {
1495                                setState(312);
1496                                switch (_input.LA(1)) {
1497                                case HTML_TAG_NAME:
1498                                        {
1499                                        setState(308);
1500                                        attribute();
1501                                        }
1502                                        break;
1503                                case NEWLINE:
1504                                        {
1505                                        setState(309);
1506                                        match(NEWLINE);
1507                                        }
1508                                        break;
1509                                case LEADING_ASTERISK:
1510                                        {
1511                                        setState(310);
1512                                        match(LEADING_ASTERISK);
1513                                        }
1514                                        break;
1515                                case WS:
1516                                        {
1517                                        setState(311);
1518                                        match(WS);
1519                                        }
1520                                        break;
1521                                default:
1522                                        throw new NoViableAltException(this);
1523                                }
1524                                }
1525                                setState(316);
1526                                _errHandler.sync(this);
1527                                _la = _input.LA(1);
1528                        }
1529                        setState(317);
1530                        match(CLOSE);
1531                        }
1532                }
1533                catch (RecognitionException re) {
1534                        _localctx.exception = re;
1535                        _errHandler.reportError(this, re);
1536                        _errHandler.recover(this, re);
1537                }
1538                finally {
1539                        exitRule();
1540                }
1541                return _localctx;
1542        }
1543
1544        public static class PTagCloseContext extends ParserRuleContext {
1545                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
1546                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
1547                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
1548                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
1549                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1550                public TerminalNode NEWLINE(int i) {
1551                        return getToken(JavadocParser.NEWLINE, i);
1552                }
1553                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1554                public TerminalNode LEADING_ASTERISK(int i) {
1555                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1556                }
1557                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
1558                public TerminalNode WS(int i) {
1559                        return getToken(JavadocParser.WS, i);
1560                }
1561                public PTagCloseContext(ParserRuleContext parent, int invokingState) {
1562                        super(parent, invokingState);
1563                }
1564                @Override public int getRuleIndex() { return RULE_pTagClose; }
1565                @Override
1566                public void enterRule(ParseTreeListener listener) {
1567                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this);
1568                }
1569                @Override
1570                public void exitRule(ParseTreeListener listener) {
1571                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this);
1572                }
1573                @Override
1574                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1575                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this);
1576                        else return visitor.visitChildren(this);
1577                }
1578        }
1579
1580        public final PTagCloseContext pTagClose() throws RecognitionException {
1581                PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState());
1582                enterRule(_localctx, 14, RULE_pTagClose);
1583                int _la;
1584                try {
1585                        enterOuterAlt(_localctx, 1);
1586                        {
1587                        setState(319);
1588                        match(OPEN);
1589                        setState(320);
1590                        match(SLASH);
1591                        setState(321);
1592                        match(P_HTML_TAG_NAME);
1593                        setState(325);
1594                        _errHandler.sync(this);
1595                        _la = _input.LA(1);
1596                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
1597                                {
1598                                {
1599                                setState(322);
1600                                _la = _input.LA(1);
1601                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
1602                                _errHandler.recoverInline(this);
1603                                } else {
1604                                        consume();
1605                                }
1606                                }
1607                                }
1608                                setState(327);
1609                                _errHandler.sync(this);
1610                                _la = _input.LA(1);
1611                        }
1612                        setState(328);
1613                        match(CLOSE);
1614                        }
1615                }
1616                catch (RecognitionException re) {
1617                        _localctx.exception = re;
1618                        _errHandler.reportError(this, re);
1619                        _errHandler.recover(this, re);
1620                }
1621                finally {
1622                        exitRule();
1623                }
1624                return _localctx;
1625        }
1626
1627        public static class ParagraphContext extends ParserRuleContext {
1628                public PTagOpenContext pTagOpen() {
1629                        return getRuleContext(PTagOpenContext.class,0);
1630                }
1631                public PTagCloseContext pTagClose() {
1632                        return getRuleContext(PTagCloseContext.class,0);
1633                }
1634                public List<HtmlTagContext> htmlTag() {
1635                        return getRuleContexts(HtmlTagContext.class);
1636                }
1637                public HtmlTagContext htmlTag(int i) {
1638                        return getRuleContext(HtmlTagContext.class,i);
1639                }
1640                public List<SingletonTagContext> singletonTag() {
1641                        return getRuleContexts(SingletonTagContext.class);
1642                }
1643                public SingletonTagContext singletonTag(int i) {
1644                        return getRuleContext(SingletonTagContext.class,i);
1645                }
1646                public List<LiContext> li() {
1647                        return getRuleContexts(LiContext.class);
1648                }
1649                public LiContext li(int i) {
1650                        return getRuleContext(LiContext.class,i);
1651                }
1652                public List<TrContext> tr() {
1653                        return getRuleContexts(TrContext.class);
1654                }
1655                public TrContext tr(int i) {
1656                        return getRuleContext(TrContext.class,i);
1657                }
1658                public List<TdContext> td() {
1659                        return getRuleContexts(TdContext.class);
1660                }
1661                public TdContext td(int i) {
1662                        return getRuleContext(TdContext.class,i);
1663                }
1664                public List<ThContext> th() {
1665                        return getRuleContexts(ThContext.class);
1666                }
1667                public ThContext th(int i) {
1668                        return getRuleContext(ThContext.class,i);
1669                }
1670                public List<BodyContext> body() {
1671                        return getRuleContexts(BodyContext.class);
1672                }
1673                public BodyContext body(int i) {
1674                        return getRuleContext(BodyContext.class,i);
1675                }
1676                public List<ColgroupContext> colgroup() {
1677                        return getRuleContexts(ColgroupContext.class);
1678                }
1679                public ColgroupContext colgroup(int i) {
1680                        return getRuleContext(ColgroupContext.class,i);
1681                }
1682                public List<DdContext> dd() {
1683                        return getRuleContexts(DdContext.class);
1684                }
1685                public DdContext dd(int i) {
1686                        return getRuleContext(DdContext.class,i);
1687                }
1688                public List<DtContext> dt() {
1689                        return getRuleContexts(DtContext.class);
1690                }
1691                public DtContext dt(int i) {
1692                        return getRuleContext(DtContext.class,i);
1693                }
1694                public List<HeadContext> head() {
1695                        return getRuleContexts(HeadContext.class);
1696                }
1697                public HeadContext head(int i) {
1698                        return getRuleContext(HeadContext.class,i);
1699                }
1700                public List<HtmlContext> html() {
1701                        return getRuleContexts(HtmlContext.class);
1702                }
1703                public HtmlContext html(int i) {
1704                        return getRuleContext(HtmlContext.class,i);
1705                }
1706                public List<OptionContext> option() {
1707                        return getRuleContexts(OptionContext.class);
1708                }
1709                public OptionContext option(int i) {
1710                        return getRuleContext(OptionContext.class,i);
1711                }
1712                public List<TbodyContext> tbody() {
1713                        return getRuleContexts(TbodyContext.class);
1714                }
1715                public TbodyContext tbody(int i) {
1716                        return getRuleContext(TbodyContext.class,i);
1717                }
1718                public List<TheadContext> thead() {
1719                        return getRuleContexts(TheadContext.class);
1720                }
1721                public TheadContext thead(int i) {
1722                        return getRuleContext(TheadContext.class,i);
1723                }
1724                public List<TfootContext> tfoot() {
1725                        return getRuleContexts(TfootContext.class);
1726                }
1727                public TfootContext tfoot(int i) {
1728                        return getRuleContext(TfootContext.class,i);
1729                }
1730                public List<LiTagOpenContext> liTagOpen() {
1731                        return getRuleContexts(LiTagOpenContext.class);
1732                }
1733                public LiTagOpenContext liTagOpen(int i) {
1734                        return getRuleContext(LiTagOpenContext.class,i);
1735                }
1736                public List<TrTagOpenContext> trTagOpen() {
1737                        return getRuleContexts(TrTagOpenContext.class);
1738                }
1739                public TrTagOpenContext trTagOpen(int i) {
1740                        return getRuleContext(TrTagOpenContext.class,i);
1741                }
1742                public List<TdTagOpenContext> tdTagOpen() {
1743                        return getRuleContexts(TdTagOpenContext.class);
1744                }
1745                public TdTagOpenContext tdTagOpen(int i) {
1746                        return getRuleContext(TdTagOpenContext.class,i);
1747                }
1748                public List<ThTagOpenContext> thTagOpen() {
1749                        return getRuleContexts(ThTagOpenContext.class);
1750                }
1751                public ThTagOpenContext thTagOpen(int i) {
1752                        return getRuleContext(ThTagOpenContext.class,i);
1753                }
1754                public List<BodyTagOpenContext> bodyTagOpen() {
1755                        return getRuleContexts(BodyTagOpenContext.class);
1756                }
1757                public BodyTagOpenContext bodyTagOpen(int i) {
1758                        return getRuleContext(BodyTagOpenContext.class,i);
1759                }
1760                public List<ColgroupTagOpenContext> colgroupTagOpen() {
1761                        return getRuleContexts(ColgroupTagOpenContext.class);
1762                }
1763                public ColgroupTagOpenContext colgroupTagOpen(int i) {
1764                        return getRuleContext(ColgroupTagOpenContext.class,i);
1765                }
1766                public List<DdTagOpenContext> ddTagOpen() {
1767                        return getRuleContexts(DdTagOpenContext.class);
1768                }
1769                public DdTagOpenContext ddTagOpen(int i) {
1770                        return getRuleContext(DdTagOpenContext.class,i);
1771                }
1772                public List<DtTagOpenContext> dtTagOpen() {
1773                        return getRuleContexts(DtTagOpenContext.class);
1774                }
1775                public DtTagOpenContext dtTagOpen(int i) {
1776                        return getRuleContext(DtTagOpenContext.class,i);
1777                }
1778                public List<HeadTagOpenContext> headTagOpen() {
1779                        return getRuleContexts(HeadTagOpenContext.class);
1780                }
1781                public HeadTagOpenContext headTagOpen(int i) {
1782                        return getRuleContext(HeadTagOpenContext.class,i);
1783                }
1784                public List<HtmlTagOpenContext> htmlTagOpen() {
1785                        return getRuleContexts(HtmlTagOpenContext.class);
1786                }
1787                public HtmlTagOpenContext htmlTagOpen(int i) {
1788                        return getRuleContext(HtmlTagOpenContext.class,i);
1789                }
1790                public List<OptionTagOpenContext> optionTagOpen() {
1791                        return getRuleContexts(OptionTagOpenContext.class);
1792                }
1793                public OptionTagOpenContext optionTagOpen(int i) {
1794                        return getRuleContext(OptionTagOpenContext.class,i);
1795                }
1796                public List<TbodyTagOpenContext> tbodyTagOpen() {
1797                        return getRuleContexts(TbodyTagOpenContext.class);
1798                }
1799                public TbodyTagOpenContext tbodyTagOpen(int i) {
1800                        return getRuleContext(TbodyTagOpenContext.class,i);
1801                }
1802                public List<TheadTagOpenContext> theadTagOpen() {
1803                        return getRuleContexts(TheadTagOpenContext.class);
1804                }
1805                public TheadTagOpenContext theadTagOpen(int i) {
1806                        return getRuleContext(TheadTagOpenContext.class,i);
1807                }
1808                public List<TfootTagOpenContext> tfootTagOpen() {
1809                        return getRuleContexts(TfootTagOpenContext.class);
1810                }
1811                public TfootTagOpenContext tfootTagOpen(int i) {
1812                        return getRuleContext(TfootTagOpenContext.class,i);
1813                }
1814                public List<HtmlCommentContext> htmlComment() {
1815                        return getRuleContexts(HtmlCommentContext.class);
1816                }
1817                public HtmlCommentContext htmlComment(int i) {
1818                        return getRuleContext(HtmlCommentContext.class,i);
1819                }
1820                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
1821                public TerminalNode CDATA(int i) {
1822                        return getToken(JavadocParser.CDATA, i);
1823                }
1824                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
1825                public TerminalNode NEWLINE(int i) {
1826                        return getToken(JavadocParser.NEWLINE, i);
1827                }
1828                public List<TextContext> text() {
1829                        return getRuleContexts(TextContext.class);
1830                }
1831                public TextContext text(int i) {
1832                        return getRuleContext(TextContext.class,i);
1833                }
1834                public List<JavadocInlineTagContext> javadocInlineTag() {
1835                        return getRuleContexts(JavadocInlineTagContext.class);
1836                }
1837                public JavadocInlineTagContext javadocInlineTag(int i) {
1838                        return getRuleContext(JavadocInlineTagContext.class,i);
1839                }
1840                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
1841                public TerminalNode LEADING_ASTERISK(int i) {
1842                        return getToken(JavadocParser.LEADING_ASTERISK, i);
1843                }
1844                public ParagraphContext(ParserRuleContext parent, int invokingState) {
1845                        super(parent, invokingState);
1846                }
1847                @Override public int getRuleIndex() { return RULE_paragraph; }
1848                @Override
1849                public void enterRule(ParseTreeListener listener) {
1850                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this);
1851                }
1852                @Override
1853                public void exitRule(ParseTreeListener listener) {
1854                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this);
1855                }
1856                @Override
1857                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
1858                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this);
1859                        else return visitor.visitChildren(this);
1860                }
1861        }
1862
1863        public final ParagraphContext paragraph() throws RecognitionException {
1864                ParagraphContext _localctx = new ParagraphContext(_ctx, getState());
1865                enterRule(_localctx, 16, RULE_paragraph);
1866                try {
1867                        int _alt;
1868                        enterOuterAlt(_localctx, 1);
1869                        {
1870                        setState(330);
1871                        pTagOpen();
1872                        setState(370);
1873                        _errHandler.sync(this);
1874                        _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1875                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1876                                if ( _alt==1 ) {
1877                                        {
1878                                        setState(368);
1879                                        _errHandler.sync(this);
1880                                        switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
1881                                        case 1:
1882                                                {
1883                                                setState(331);
1884                                                htmlTag();
1885                                                }
1886                                                break;
1887                                        case 2:
1888                                                {
1889                                                setState(332);
1890                                                singletonTag();
1891                                                }
1892                                                break;
1893                                        case 3:
1894                                                {
1895                                                setState(333);
1896                                                li();
1897                                                }
1898                                                break;
1899                                        case 4:
1900                                                {
1901                                                setState(334);
1902                                                tr();
1903                                                }
1904                                                break;
1905                                        case 5:
1906                                                {
1907                                                setState(335);
1908                                                td();
1909                                                }
1910                                                break;
1911                                        case 6:
1912                                                {
1913                                                setState(336);
1914                                                th();
1915                                                }
1916                                                break;
1917                                        case 7:
1918                                                {
1919                                                setState(337);
1920                                                body();
1921                                                }
1922                                                break;
1923                                        case 8:
1924                                                {
1925                                                setState(338);
1926                                                colgroup();
1927                                                }
1928                                                break;
1929                                        case 9:
1930                                                {
1931                                                setState(339);
1932                                                dd();
1933                                                }
1934                                                break;
1935                                        case 10:
1936                                                {
1937                                                setState(340);
1938                                                dt();
1939                                                }
1940                                                break;
1941                                        case 11:
1942                                                {
1943                                                setState(341);
1944                                                head();
1945                                                }
1946                                                break;
1947                                        case 12:
1948                                                {
1949                                                setState(342);
1950                                                html();
1951                                                }
1952                                                break;
1953                                        case 13:
1954                                                {
1955                                                setState(343);
1956                                                option();
1957                                                }
1958                                                break;
1959                                        case 14:
1960                                                {
1961                                                setState(344);
1962                                                tbody();
1963                                                }
1964                                                break;
1965                                        case 15:
1966                                                {
1967                                                setState(345);
1968                                                thead();
1969                                                }
1970                                                break;
1971                                        case 16:
1972                                                {
1973                                                setState(346);
1974                                                tfoot();
1975                                                }
1976                                                break;
1977                                        case 17:
1978                                                {
1979                                                setState(347);
1980                                                liTagOpen();
1981                                                }
1982                                                break;
1983                                        case 18:
1984                                                {
1985                                                setState(348);
1986                                                trTagOpen();
1987                                                }
1988                                                break;
1989                                        case 19:
1990                                                {
1991                                                setState(349);
1992                                                tdTagOpen();
1993                                                }
1994                                                break;
1995                                        case 20:
1996                                                {
1997                                                setState(350);
1998                                                thTagOpen();
1999                                                }
2000                                                break;
2001                                        case 21:
2002                                                {
2003                                                setState(351);
2004                                                bodyTagOpen();
2005                                                }
2006                                                break;
2007                                        case 22:
2008                                                {
2009                                                setState(352);
2010                                                colgroupTagOpen();
2011                                                }
2012                                                break;
2013                                        case 23:
2014                                                {
2015                                                setState(353);
2016                                                ddTagOpen();
2017                                                }
2018                                                break;
2019                                        case 24:
2020                                                {
2021                                                setState(354);
2022                                                dtTagOpen();
2023                                                }
2024                                                break;
2025                                        case 25:
2026                                                {
2027                                                setState(355);
2028                                                headTagOpen();
2029                                                }
2030                                                break;
2031                                        case 26:
2032                                                {
2033                                                setState(356);
2034                                                htmlTagOpen();
2035                                                }
2036                                                break;
2037                                        case 27:
2038                                                {
2039                                                setState(357);
2040                                                optionTagOpen();
2041                                                }
2042                                                break;
2043                                        case 28:
2044                                                {
2045                                                setState(358);
2046                                                tbodyTagOpen();
2047                                                }
2048                                                break;
2049                                        case 29:
2050                                                {
2051                                                setState(359);
2052                                                theadTagOpen();
2053                                                }
2054                                                break;
2055                                        case 30:
2056                                                {
2057                                                setState(360);
2058                                                tfootTagOpen();
2059                                                }
2060                                                break;
2061                                        case 31:
2062                                                {
2063                                                {
2064                                                setState(361);
2065                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2066                                                setState(362);
2067                                                match(LEADING_ASTERISK);
2068                                                }
2069                                                }
2070                                                break;
2071                                        case 32:
2072                                                {
2073                                                setState(363);
2074                                                htmlComment();
2075                                                }
2076                                                break;
2077                                        case 33:
2078                                                {
2079                                                setState(364);
2080                                                match(CDATA);
2081                                                }
2082                                                break;
2083                                        case 34:
2084                                                {
2085                                                setState(365);
2086                                                match(NEWLINE);
2087                                                }
2088                                                break;
2089                                        case 35:
2090                                                {
2091                                                setState(366);
2092                                                text();
2093                                                }
2094                                                break;
2095                                        case 36:
2096                                                {
2097                                                setState(367);
2098                                                javadocInlineTag();
2099                                                }
2100                                                break;
2101                                        }
2102                                        } 
2103                                }
2104                                setState(372);
2105                                _errHandler.sync(this);
2106                                _alt = getInterpreter().adaptivePredict(_input,21,_ctx);
2107                        }
2108                        setState(373);
2109                        pTagClose();
2110                        }
2111                }
2112                catch (RecognitionException re) {
2113                        _localctx.exception = re;
2114                        _errHandler.reportError(this, re);
2115                        _errHandler.recover(this, re);
2116                }
2117                finally {
2118                        exitRule();
2119                }
2120                return _localctx;
2121        }
2122
2123        public static class LiTagOpenContext extends ParserRuleContext {
2124                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2125                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2126                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2127                public List<AttributeContext> attribute() {
2128                        return getRuleContexts(AttributeContext.class);
2129                }
2130                public AttributeContext attribute(int i) {
2131                        return getRuleContext(AttributeContext.class,i);
2132                }
2133                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2134                public TerminalNode NEWLINE(int i) {
2135                        return getToken(JavadocParser.NEWLINE, i);
2136                }
2137                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2138                public TerminalNode LEADING_ASTERISK(int i) {
2139                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2140                }
2141                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2142                public TerminalNode WS(int i) {
2143                        return getToken(JavadocParser.WS, i);
2144                }
2145                public LiTagOpenContext(ParserRuleContext parent, int invokingState) {
2146                        super(parent, invokingState);
2147                }
2148                @Override public int getRuleIndex() { return RULE_liTagOpen; }
2149                @Override
2150                public void enterRule(ParseTreeListener listener) {
2151                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this);
2152                }
2153                @Override
2154                public void exitRule(ParseTreeListener listener) {
2155                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this);
2156                }
2157                @Override
2158                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2159                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this);
2160                        else return visitor.visitChildren(this);
2161                }
2162        }
2163
2164        public final LiTagOpenContext liTagOpen() throws RecognitionException {
2165                LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState());
2166                enterRule(_localctx, 18, RULE_liTagOpen);
2167                int _la;
2168                try {
2169                        enterOuterAlt(_localctx, 1);
2170                        {
2171                        setState(375);
2172                        match(OPEN);
2173                        setState(376);
2174                        match(LI_HTML_TAG_NAME);
2175                        setState(383);
2176                        _errHandler.sync(this);
2177                        _la = _input.LA(1);
2178                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2179                                {
2180                                setState(381);
2181                                switch (_input.LA(1)) {
2182                                case HTML_TAG_NAME:
2183                                        {
2184                                        setState(377);
2185                                        attribute();
2186                                        }
2187                                        break;
2188                                case NEWLINE:
2189                                        {
2190                                        setState(378);
2191                                        match(NEWLINE);
2192                                        }
2193                                        break;
2194                                case LEADING_ASTERISK:
2195                                        {
2196                                        setState(379);
2197                                        match(LEADING_ASTERISK);
2198                                        }
2199                                        break;
2200                                case WS:
2201                                        {
2202                                        setState(380);
2203                                        match(WS);
2204                                        }
2205                                        break;
2206                                default:
2207                                        throw new NoViableAltException(this);
2208                                }
2209                                }
2210                                setState(385);
2211                                _errHandler.sync(this);
2212                                _la = _input.LA(1);
2213                        }
2214                        setState(386);
2215                        match(CLOSE);
2216                        }
2217                }
2218                catch (RecognitionException re) {
2219                        _localctx.exception = re;
2220                        _errHandler.reportError(this, re);
2221                        _errHandler.recover(this, re);
2222                }
2223                finally {
2224                        exitRule();
2225                }
2226                return _localctx;
2227        }
2228
2229        public static class LiTagCloseContext extends ParserRuleContext {
2230                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2231                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2232                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
2233                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2234                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2235                public TerminalNode NEWLINE(int i) {
2236                        return getToken(JavadocParser.NEWLINE, i);
2237                }
2238                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2239                public TerminalNode LEADING_ASTERISK(int i) {
2240                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2241                }
2242                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2243                public TerminalNode WS(int i) {
2244                        return getToken(JavadocParser.WS, i);
2245                }
2246                public LiTagCloseContext(ParserRuleContext parent, int invokingState) {
2247                        super(parent, invokingState);
2248                }
2249                @Override public int getRuleIndex() { return RULE_liTagClose; }
2250                @Override
2251                public void enterRule(ParseTreeListener listener) {
2252                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this);
2253                }
2254                @Override
2255                public void exitRule(ParseTreeListener listener) {
2256                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this);
2257                }
2258                @Override
2259                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2260                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this);
2261                        else return visitor.visitChildren(this);
2262                }
2263        }
2264
2265        public final LiTagCloseContext liTagClose() throws RecognitionException {
2266                LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState());
2267                enterRule(_localctx, 20, RULE_liTagClose);
2268                int _la;
2269                try {
2270                        enterOuterAlt(_localctx, 1);
2271                        {
2272                        setState(388);
2273                        match(OPEN);
2274                        setState(389);
2275                        match(SLASH);
2276                        setState(390);
2277                        match(LI_HTML_TAG_NAME);
2278                        setState(394);
2279                        _errHandler.sync(this);
2280                        _la = _input.LA(1);
2281                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2282                                {
2283                                {
2284                                setState(391);
2285                                _la = _input.LA(1);
2286                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2287                                _errHandler.recoverInline(this);
2288                                } else {
2289                                        consume();
2290                                }
2291                                }
2292                                }
2293                                setState(396);
2294                                _errHandler.sync(this);
2295                                _la = _input.LA(1);
2296                        }
2297                        setState(397);
2298                        match(CLOSE);
2299                        }
2300                }
2301                catch (RecognitionException re) {
2302                        _localctx.exception = re;
2303                        _errHandler.reportError(this, re);
2304                        _errHandler.recover(this, re);
2305                }
2306                finally {
2307                        exitRule();
2308                }
2309                return _localctx;
2310        }
2311
2312        public static class LiContext extends ParserRuleContext {
2313                public LiTagOpenContext liTagOpen() {
2314                        return getRuleContext(LiTagOpenContext.class,0);
2315                }
2316                public LiTagCloseContext liTagClose() {
2317                        return getRuleContext(LiTagCloseContext.class,0);
2318                }
2319                public List<HtmlTagContext> htmlTag() {
2320                        return getRuleContexts(HtmlTagContext.class);
2321                }
2322                public HtmlTagContext htmlTag(int i) {
2323                        return getRuleContext(HtmlTagContext.class,i);
2324                }
2325                public List<SingletonTagContext> singletonTag() {
2326                        return getRuleContexts(SingletonTagContext.class);
2327                }
2328                public SingletonTagContext singletonTag(int i) {
2329                        return getRuleContext(SingletonTagContext.class,i);
2330                }
2331                public List<ParagraphContext> paragraph() {
2332                        return getRuleContexts(ParagraphContext.class);
2333                }
2334                public ParagraphContext paragraph(int i) {
2335                        return getRuleContext(ParagraphContext.class,i);
2336                }
2337                public List<TrContext> tr() {
2338                        return getRuleContexts(TrContext.class);
2339                }
2340                public TrContext tr(int i) {
2341                        return getRuleContext(TrContext.class,i);
2342                }
2343                public List<TdContext> td() {
2344                        return getRuleContexts(TdContext.class);
2345                }
2346                public TdContext td(int i) {
2347                        return getRuleContext(TdContext.class,i);
2348                }
2349                public List<ThContext> th() {
2350                        return getRuleContexts(ThContext.class);
2351                }
2352                public ThContext th(int i) {
2353                        return getRuleContext(ThContext.class,i);
2354                }
2355                public List<BodyContext> body() {
2356                        return getRuleContexts(BodyContext.class);
2357                }
2358                public BodyContext body(int i) {
2359                        return getRuleContext(BodyContext.class,i);
2360                }
2361                public List<ColgroupContext> colgroup() {
2362                        return getRuleContexts(ColgroupContext.class);
2363                }
2364                public ColgroupContext colgroup(int i) {
2365                        return getRuleContext(ColgroupContext.class,i);
2366                }
2367                public List<DdContext> dd() {
2368                        return getRuleContexts(DdContext.class);
2369                }
2370                public DdContext dd(int i) {
2371                        return getRuleContext(DdContext.class,i);
2372                }
2373                public List<DtContext> dt() {
2374                        return getRuleContexts(DtContext.class);
2375                }
2376                public DtContext dt(int i) {
2377                        return getRuleContext(DtContext.class,i);
2378                }
2379                public List<HeadContext> head() {
2380                        return getRuleContexts(HeadContext.class);
2381                }
2382                public HeadContext head(int i) {
2383                        return getRuleContext(HeadContext.class,i);
2384                }
2385                public List<HtmlContext> html() {
2386                        return getRuleContexts(HtmlContext.class);
2387                }
2388                public HtmlContext html(int i) {
2389                        return getRuleContext(HtmlContext.class,i);
2390                }
2391                public List<OptionContext> option() {
2392                        return getRuleContexts(OptionContext.class);
2393                }
2394                public OptionContext option(int i) {
2395                        return getRuleContext(OptionContext.class,i);
2396                }
2397                public List<TbodyContext> tbody() {
2398                        return getRuleContexts(TbodyContext.class);
2399                }
2400                public TbodyContext tbody(int i) {
2401                        return getRuleContext(TbodyContext.class,i);
2402                }
2403                public List<TheadContext> thead() {
2404                        return getRuleContexts(TheadContext.class);
2405                }
2406                public TheadContext thead(int i) {
2407                        return getRuleContext(TheadContext.class,i);
2408                }
2409                public List<TfootContext> tfoot() {
2410                        return getRuleContexts(TfootContext.class);
2411                }
2412                public TfootContext tfoot(int i) {
2413                        return getRuleContext(TfootContext.class,i);
2414                }
2415                public List<PTagOpenContext> pTagOpen() {
2416                        return getRuleContexts(PTagOpenContext.class);
2417                }
2418                public PTagOpenContext pTagOpen(int i) {
2419                        return getRuleContext(PTagOpenContext.class,i);
2420                }
2421                public List<TrTagOpenContext> trTagOpen() {
2422                        return getRuleContexts(TrTagOpenContext.class);
2423                }
2424                public TrTagOpenContext trTagOpen(int i) {
2425                        return getRuleContext(TrTagOpenContext.class,i);
2426                }
2427                public List<TdTagOpenContext> tdTagOpen() {
2428                        return getRuleContexts(TdTagOpenContext.class);
2429                }
2430                public TdTagOpenContext tdTagOpen(int i) {
2431                        return getRuleContext(TdTagOpenContext.class,i);
2432                }
2433                public List<ThTagOpenContext> thTagOpen() {
2434                        return getRuleContexts(ThTagOpenContext.class);
2435                }
2436                public ThTagOpenContext thTagOpen(int i) {
2437                        return getRuleContext(ThTagOpenContext.class,i);
2438                }
2439                public List<BodyTagOpenContext> bodyTagOpen() {
2440                        return getRuleContexts(BodyTagOpenContext.class);
2441                }
2442                public BodyTagOpenContext bodyTagOpen(int i) {
2443                        return getRuleContext(BodyTagOpenContext.class,i);
2444                }
2445                public List<ColgroupTagOpenContext> colgroupTagOpen() {
2446                        return getRuleContexts(ColgroupTagOpenContext.class);
2447                }
2448                public ColgroupTagOpenContext colgroupTagOpen(int i) {
2449                        return getRuleContext(ColgroupTagOpenContext.class,i);
2450                }
2451                public List<DdTagOpenContext> ddTagOpen() {
2452                        return getRuleContexts(DdTagOpenContext.class);
2453                }
2454                public DdTagOpenContext ddTagOpen(int i) {
2455                        return getRuleContext(DdTagOpenContext.class,i);
2456                }
2457                public List<DtTagOpenContext> dtTagOpen() {
2458                        return getRuleContexts(DtTagOpenContext.class);
2459                }
2460                public DtTagOpenContext dtTagOpen(int i) {
2461                        return getRuleContext(DtTagOpenContext.class,i);
2462                }
2463                public List<HeadTagOpenContext> headTagOpen() {
2464                        return getRuleContexts(HeadTagOpenContext.class);
2465                }
2466                public HeadTagOpenContext headTagOpen(int i) {
2467                        return getRuleContext(HeadTagOpenContext.class,i);
2468                }
2469                public List<HtmlTagOpenContext> htmlTagOpen() {
2470                        return getRuleContexts(HtmlTagOpenContext.class);
2471                }
2472                public HtmlTagOpenContext htmlTagOpen(int i) {
2473                        return getRuleContext(HtmlTagOpenContext.class,i);
2474                }
2475                public List<OptionTagOpenContext> optionTagOpen() {
2476                        return getRuleContexts(OptionTagOpenContext.class);
2477                }
2478                public OptionTagOpenContext optionTagOpen(int i) {
2479                        return getRuleContext(OptionTagOpenContext.class,i);
2480                }
2481                public List<TbodyTagOpenContext> tbodyTagOpen() {
2482                        return getRuleContexts(TbodyTagOpenContext.class);
2483                }
2484                public TbodyTagOpenContext tbodyTagOpen(int i) {
2485                        return getRuleContext(TbodyTagOpenContext.class,i);
2486                }
2487                public List<TheadTagOpenContext> theadTagOpen() {
2488                        return getRuleContexts(TheadTagOpenContext.class);
2489                }
2490                public TheadTagOpenContext theadTagOpen(int i) {
2491                        return getRuleContext(TheadTagOpenContext.class,i);
2492                }
2493                public List<TfootTagOpenContext> tfootTagOpen() {
2494                        return getRuleContexts(TfootTagOpenContext.class);
2495                }
2496                public TfootTagOpenContext tfootTagOpen(int i) {
2497                        return getRuleContext(TfootTagOpenContext.class,i);
2498                }
2499                public List<HtmlCommentContext> htmlComment() {
2500                        return getRuleContexts(HtmlCommentContext.class);
2501                }
2502                public HtmlCommentContext htmlComment(int i) {
2503                        return getRuleContext(HtmlCommentContext.class,i);
2504                }
2505                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
2506                public TerminalNode CDATA(int i) {
2507                        return getToken(JavadocParser.CDATA, i);
2508                }
2509                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2510                public TerminalNode NEWLINE(int i) {
2511                        return getToken(JavadocParser.NEWLINE, i);
2512                }
2513                public List<TextContext> text() {
2514                        return getRuleContexts(TextContext.class);
2515                }
2516                public TextContext text(int i) {
2517                        return getRuleContext(TextContext.class,i);
2518                }
2519                public List<JavadocInlineTagContext> javadocInlineTag() {
2520                        return getRuleContexts(JavadocInlineTagContext.class);
2521                }
2522                public JavadocInlineTagContext javadocInlineTag(int i) {
2523                        return getRuleContext(JavadocInlineTagContext.class,i);
2524                }
2525                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2526                public TerminalNode LEADING_ASTERISK(int i) {
2527                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2528                }
2529                public LiContext(ParserRuleContext parent, int invokingState) {
2530                        super(parent, invokingState);
2531                }
2532                @Override public int getRuleIndex() { return RULE_li; }
2533                @Override
2534                public void enterRule(ParseTreeListener listener) {
2535                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this);
2536                }
2537                @Override
2538                public void exitRule(ParseTreeListener listener) {
2539                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this);
2540                }
2541                @Override
2542                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2543                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this);
2544                        else return visitor.visitChildren(this);
2545                }
2546        }
2547
2548        public final LiContext li() throws RecognitionException {
2549                LiContext _localctx = new LiContext(_ctx, getState());
2550                enterRule(_localctx, 22, RULE_li);
2551                try {
2552                        int _alt;
2553                        enterOuterAlt(_localctx, 1);
2554                        {
2555                        setState(399);
2556                        liTagOpen();
2557                        setState(439);
2558                        _errHandler.sync(this);
2559                        _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2560                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2561                                if ( _alt==1 ) {
2562                                        {
2563                                        setState(437);
2564                                        _errHandler.sync(this);
2565                                        switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
2566                                        case 1:
2567                                                {
2568                                                setState(400);
2569                                                htmlTag();
2570                                                }
2571                                                break;
2572                                        case 2:
2573                                                {
2574                                                setState(401);
2575                                                singletonTag();
2576                                                }
2577                                                break;
2578                                        case 3:
2579                                                {
2580                                                setState(402);
2581                                                paragraph();
2582                                                }
2583                                                break;
2584                                        case 4:
2585                                                {
2586                                                setState(403);
2587                                                tr();
2588                                                }
2589                                                break;
2590                                        case 5:
2591                                                {
2592                                                setState(404);
2593                                                td();
2594                                                }
2595                                                break;
2596                                        case 6:
2597                                                {
2598                                                setState(405);
2599                                                th();
2600                                                }
2601                                                break;
2602                                        case 7:
2603                                                {
2604                                                setState(406);
2605                                                body();
2606                                                }
2607                                                break;
2608                                        case 8:
2609                                                {
2610                                                setState(407);
2611                                                colgroup();
2612                                                }
2613                                                break;
2614                                        case 9:
2615                                                {
2616                                                setState(408);
2617                                                dd();
2618                                                }
2619                                                break;
2620                                        case 10:
2621                                                {
2622                                                setState(409);
2623                                                dt();
2624                                                }
2625                                                break;
2626                                        case 11:
2627                                                {
2628                                                setState(410);
2629                                                head();
2630                                                }
2631                                                break;
2632                                        case 12:
2633                                                {
2634                                                setState(411);
2635                                                html();
2636                                                }
2637                                                break;
2638                                        case 13:
2639                                                {
2640                                                setState(412);
2641                                                option();
2642                                                }
2643                                                break;
2644                                        case 14:
2645                                                {
2646                                                setState(413);
2647                                                tbody();
2648                                                }
2649                                                break;
2650                                        case 15:
2651                                                {
2652                                                setState(414);
2653                                                thead();
2654                                                }
2655                                                break;
2656                                        case 16:
2657                                                {
2658                                                setState(415);
2659                                                tfoot();
2660                                                }
2661                                                break;
2662                                        case 17:
2663                                                {
2664                                                setState(416);
2665                                                pTagOpen();
2666                                                }
2667                                                break;
2668                                        case 18:
2669                                                {
2670                                                setState(417);
2671                                                trTagOpen();
2672                                                }
2673                                                break;
2674                                        case 19:
2675                                                {
2676                                                setState(418);
2677                                                tdTagOpen();
2678                                                }
2679                                                break;
2680                                        case 20:
2681                                                {
2682                                                setState(419);
2683                                                thTagOpen();
2684                                                }
2685                                                break;
2686                                        case 21:
2687                                                {
2688                                                setState(420);
2689                                                bodyTagOpen();
2690                                                }
2691                                                break;
2692                                        case 22:
2693                                                {
2694                                                setState(421);
2695                                                colgroupTagOpen();
2696                                                }
2697                                                break;
2698                                        case 23:
2699                                                {
2700                                                setState(422);
2701                                                ddTagOpen();
2702                                                }
2703                                                break;
2704                                        case 24:
2705                                                {
2706                                                setState(423);
2707                                                dtTagOpen();
2708                                                }
2709                                                break;
2710                                        case 25:
2711                                                {
2712                                                setState(424);
2713                                                headTagOpen();
2714                                                }
2715                                                break;
2716                                        case 26:
2717                                                {
2718                                                setState(425);
2719                                                htmlTagOpen();
2720                                                }
2721                                                break;
2722                                        case 27:
2723                                                {
2724                                                setState(426);
2725                                                optionTagOpen();
2726                                                }
2727                                                break;
2728                                        case 28:
2729                                                {
2730                                                setState(427);
2731                                                tbodyTagOpen();
2732                                                }
2733                                                break;
2734                                        case 29:
2735                                                {
2736                                                setState(428);
2737                                                theadTagOpen();
2738                                                }
2739                                                break;
2740                                        case 30:
2741                                                {
2742                                                setState(429);
2743                                                tfootTagOpen();
2744                                                }
2745                                                break;
2746                                        case 31:
2747                                                {
2748                                                {
2749                                                setState(430);
2750                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
2751                                                setState(431);
2752                                                match(LEADING_ASTERISK);
2753                                                }
2754                                                }
2755                                                break;
2756                                        case 32:
2757                                                {
2758                                                setState(432);
2759                                                htmlComment();
2760                                                }
2761                                                break;
2762                                        case 33:
2763                                                {
2764                                                setState(433);
2765                                                match(CDATA);
2766                                                }
2767                                                break;
2768                                        case 34:
2769                                                {
2770                                                setState(434);
2771                                                match(NEWLINE);
2772                                                }
2773                                                break;
2774                                        case 35:
2775                                                {
2776                                                setState(435);
2777                                                text();
2778                                                }
2779                                                break;
2780                                        case 36:
2781                                                {
2782                                                setState(436);
2783                                                javadocInlineTag();
2784                                                }
2785                                                break;
2786                                        }
2787                                        } 
2788                                }
2789                                setState(441);
2790                                _errHandler.sync(this);
2791                                _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
2792                        }
2793                        setState(442);
2794                        liTagClose();
2795                        }
2796                }
2797                catch (RecognitionException re) {
2798                        _localctx.exception = re;
2799                        _errHandler.reportError(this, re);
2800                        _errHandler.recover(this, re);
2801                }
2802                finally {
2803                        exitRule();
2804                }
2805                return _localctx;
2806        }
2807
2808        public static class TrTagOpenContext extends ParserRuleContext {
2809                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2810                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2811                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2812                public List<AttributeContext> attribute() {
2813                        return getRuleContexts(AttributeContext.class);
2814                }
2815                public AttributeContext attribute(int i) {
2816                        return getRuleContext(AttributeContext.class,i);
2817                }
2818                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2819                public TerminalNode NEWLINE(int i) {
2820                        return getToken(JavadocParser.NEWLINE, i);
2821                }
2822                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2823                public TerminalNode LEADING_ASTERISK(int i) {
2824                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2825                }
2826                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2827                public TerminalNode WS(int i) {
2828                        return getToken(JavadocParser.WS, i);
2829                }
2830                public TrTagOpenContext(ParserRuleContext parent, int invokingState) {
2831                        super(parent, invokingState);
2832                }
2833                @Override public int getRuleIndex() { return RULE_trTagOpen; }
2834                @Override
2835                public void enterRule(ParseTreeListener listener) {
2836                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this);
2837                }
2838                @Override
2839                public void exitRule(ParseTreeListener listener) {
2840                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this);
2841                }
2842                @Override
2843                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2844                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this);
2845                        else return visitor.visitChildren(this);
2846                }
2847        }
2848
2849        public final TrTagOpenContext trTagOpen() throws RecognitionException {
2850                TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState());
2851                enterRule(_localctx, 24, RULE_trTagOpen);
2852                int _la;
2853                try {
2854                        enterOuterAlt(_localctx, 1);
2855                        {
2856                        setState(444);
2857                        match(OPEN);
2858                        setState(445);
2859                        match(TR_HTML_TAG_NAME);
2860                        setState(452);
2861                        _errHandler.sync(this);
2862                        _la = _input.LA(1);
2863                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
2864                                {
2865                                setState(450);
2866                                switch (_input.LA(1)) {
2867                                case HTML_TAG_NAME:
2868                                        {
2869                                        setState(446);
2870                                        attribute();
2871                                        }
2872                                        break;
2873                                case NEWLINE:
2874                                        {
2875                                        setState(447);
2876                                        match(NEWLINE);
2877                                        }
2878                                        break;
2879                                case LEADING_ASTERISK:
2880                                        {
2881                                        setState(448);
2882                                        match(LEADING_ASTERISK);
2883                                        }
2884                                        break;
2885                                case WS:
2886                                        {
2887                                        setState(449);
2888                                        match(WS);
2889                                        }
2890                                        break;
2891                                default:
2892                                        throw new NoViableAltException(this);
2893                                }
2894                                }
2895                                setState(454);
2896                                _errHandler.sync(this);
2897                                _la = _input.LA(1);
2898                        }
2899                        setState(455);
2900                        match(CLOSE);
2901                        }
2902                }
2903                catch (RecognitionException re) {
2904                        _localctx.exception = re;
2905                        _errHandler.reportError(this, re);
2906                        _errHandler.recover(this, re);
2907                }
2908                finally {
2909                        exitRule();
2910                }
2911                return _localctx;
2912        }
2913
2914        public static class TrTagCloseContext extends ParserRuleContext {
2915                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
2916                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
2917                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
2918                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
2919                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
2920                public TerminalNode NEWLINE(int i) {
2921                        return getToken(JavadocParser.NEWLINE, i);
2922                }
2923                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
2924                public TerminalNode LEADING_ASTERISK(int i) {
2925                        return getToken(JavadocParser.LEADING_ASTERISK, i);
2926                }
2927                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
2928                public TerminalNode WS(int i) {
2929                        return getToken(JavadocParser.WS, i);
2930                }
2931                public TrTagCloseContext(ParserRuleContext parent, int invokingState) {
2932                        super(parent, invokingState);
2933                }
2934                @Override public int getRuleIndex() { return RULE_trTagClose; }
2935                @Override
2936                public void enterRule(ParseTreeListener listener) {
2937                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this);
2938                }
2939                @Override
2940                public void exitRule(ParseTreeListener listener) {
2941                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this);
2942                }
2943                @Override
2944                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
2945                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this);
2946                        else return visitor.visitChildren(this);
2947                }
2948        }
2949
2950        public final TrTagCloseContext trTagClose() throws RecognitionException {
2951                TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState());
2952                enterRule(_localctx, 26, RULE_trTagClose);
2953                int _la;
2954                try {
2955                        enterOuterAlt(_localctx, 1);
2956                        {
2957                        setState(457);
2958                        match(OPEN);
2959                        setState(458);
2960                        match(SLASH);
2961                        setState(459);
2962                        match(TR_HTML_TAG_NAME);
2963                        setState(463);
2964                        _errHandler.sync(this);
2965                        _la = _input.LA(1);
2966                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
2967                                {
2968                                {
2969                                setState(460);
2970                                _la = _input.LA(1);
2971                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
2972                                _errHandler.recoverInline(this);
2973                                } else {
2974                                        consume();
2975                                }
2976                                }
2977                                }
2978                                setState(465);
2979                                _errHandler.sync(this);
2980                                _la = _input.LA(1);
2981                        }
2982                        setState(466);
2983                        match(CLOSE);
2984                        }
2985                }
2986                catch (RecognitionException re) {
2987                        _localctx.exception = re;
2988                        _errHandler.reportError(this, re);
2989                        _errHandler.recover(this, re);
2990                }
2991                finally {
2992                        exitRule();
2993                }
2994                return _localctx;
2995        }
2996
2997        public static class TrContext extends ParserRuleContext {
2998                public TrTagOpenContext trTagOpen() {
2999                        return getRuleContext(TrTagOpenContext.class,0);
3000                }
3001                public TrTagCloseContext trTagClose() {
3002                        return getRuleContext(TrTagCloseContext.class,0);
3003                }
3004                public List<HtmlTagContext> htmlTag() {
3005                        return getRuleContexts(HtmlTagContext.class);
3006                }
3007                public HtmlTagContext htmlTag(int i) {
3008                        return getRuleContext(HtmlTagContext.class,i);
3009                }
3010                public List<SingletonTagContext> singletonTag() {
3011                        return getRuleContexts(SingletonTagContext.class);
3012                }
3013                public SingletonTagContext singletonTag(int i) {
3014                        return getRuleContext(SingletonTagContext.class,i);
3015                }
3016                public List<ParagraphContext> paragraph() {
3017                        return getRuleContexts(ParagraphContext.class);
3018                }
3019                public ParagraphContext paragraph(int i) {
3020                        return getRuleContext(ParagraphContext.class,i);
3021                }
3022                public List<LiContext> li() {
3023                        return getRuleContexts(LiContext.class);
3024                }
3025                public LiContext li(int i) {
3026                        return getRuleContext(LiContext.class,i);
3027                }
3028                public List<TdContext> td() {
3029                        return getRuleContexts(TdContext.class);
3030                }
3031                public TdContext td(int i) {
3032                        return getRuleContext(TdContext.class,i);
3033                }
3034                public List<ThContext> th() {
3035                        return getRuleContexts(ThContext.class);
3036                }
3037                public ThContext th(int i) {
3038                        return getRuleContext(ThContext.class,i);
3039                }
3040                public List<BodyContext> body() {
3041                        return getRuleContexts(BodyContext.class);
3042                }
3043                public BodyContext body(int i) {
3044                        return getRuleContext(BodyContext.class,i);
3045                }
3046                public List<ColgroupContext> colgroup() {
3047                        return getRuleContexts(ColgroupContext.class);
3048                }
3049                public ColgroupContext colgroup(int i) {
3050                        return getRuleContext(ColgroupContext.class,i);
3051                }
3052                public List<DdContext> dd() {
3053                        return getRuleContexts(DdContext.class);
3054                }
3055                public DdContext dd(int i) {
3056                        return getRuleContext(DdContext.class,i);
3057                }
3058                public List<DtContext> dt() {
3059                        return getRuleContexts(DtContext.class);
3060                }
3061                public DtContext dt(int i) {
3062                        return getRuleContext(DtContext.class,i);
3063                }
3064                public List<HeadContext> head() {
3065                        return getRuleContexts(HeadContext.class);
3066                }
3067                public HeadContext head(int i) {
3068                        return getRuleContext(HeadContext.class,i);
3069                }
3070                public List<HtmlContext> html() {
3071                        return getRuleContexts(HtmlContext.class);
3072                }
3073                public HtmlContext html(int i) {
3074                        return getRuleContext(HtmlContext.class,i);
3075                }
3076                public List<OptionContext> option() {
3077                        return getRuleContexts(OptionContext.class);
3078                }
3079                public OptionContext option(int i) {
3080                        return getRuleContext(OptionContext.class,i);
3081                }
3082                public List<TbodyContext> tbody() {
3083                        return getRuleContexts(TbodyContext.class);
3084                }
3085                public TbodyContext tbody(int i) {
3086                        return getRuleContext(TbodyContext.class,i);
3087                }
3088                public List<TheadContext> thead() {
3089                        return getRuleContexts(TheadContext.class);
3090                }
3091                public TheadContext thead(int i) {
3092                        return getRuleContext(TheadContext.class,i);
3093                }
3094                public List<TfootContext> tfoot() {
3095                        return getRuleContexts(TfootContext.class);
3096                }
3097                public TfootContext tfoot(int i) {
3098                        return getRuleContext(TfootContext.class,i);
3099                }
3100                public List<PTagOpenContext> pTagOpen() {
3101                        return getRuleContexts(PTagOpenContext.class);
3102                }
3103                public PTagOpenContext pTagOpen(int i) {
3104                        return getRuleContext(PTagOpenContext.class,i);
3105                }
3106                public List<LiTagOpenContext> liTagOpen() {
3107                        return getRuleContexts(LiTagOpenContext.class);
3108                }
3109                public LiTagOpenContext liTagOpen(int i) {
3110                        return getRuleContext(LiTagOpenContext.class,i);
3111                }
3112                public List<TdTagOpenContext> tdTagOpen() {
3113                        return getRuleContexts(TdTagOpenContext.class);
3114                }
3115                public TdTagOpenContext tdTagOpen(int i) {
3116                        return getRuleContext(TdTagOpenContext.class,i);
3117                }
3118                public List<ThTagOpenContext> thTagOpen() {
3119                        return getRuleContexts(ThTagOpenContext.class);
3120                }
3121                public ThTagOpenContext thTagOpen(int i) {
3122                        return getRuleContext(ThTagOpenContext.class,i);
3123                }
3124                public List<BodyTagOpenContext> bodyTagOpen() {
3125                        return getRuleContexts(BodyTagOpenContext.class);
3126                }
3127                public BodyTagOpenContext bodyTagOpen(int i) {
3128                        return getRuleContext(BodyTagOpenContext.class,i);
3129                }
3130                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3131                        return getRuleContexts(ColgroupTagOpenContext.class);
3132                }
3133                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3134                        return getRuleContext(ColgroupTagOpenContext.class,i);
3135                }
3136                public List<DdTagOpenContext> ddTagOpen() {
3137                        return getRuleContexts(DdTagOpenContext.class);
3138                }
3139                public DdTagOpenContext ddTagOpen(int i) {
3140                        return getRuleContext(DdTagOpenContext.class,i);
3141                }
3142                public List<DtTagOpenContext> dtTagOpen() {
3143                        return getRuleContexts(DtTagOpenContext.class);
3144                }
3145                public DtTagOpenContext dtTagOpen(int i) {
3146                        return getRuleContext(DtTagOpenContext.class,i);
3147                }
3148                public List<HeadTagOpenContext> headTagOpen() {
3149                        return getRuleContexts(HeadTagOpenContext.class);
3150                }
3151                public HeadTagOpenContext headTagOpen(int i) {
3152                        return getRuleContext(HeadTagOpenContext.class,i);
3153                }
3154                public List<HtmlTagOpenContext> htmlTagOpen() {
3155                        return getRuleContexts(HtmlTagOpenContext.class);
3156                }
3157                public HtmlTagOpenContext htmlTagOpen(int i) {
3158                        return getRuleContext(HtmlTagOpenContext.class,i);
3159                }
3160                public List<OptionTagOpenContext> optionTagOpen() {
3161                        return getRuleContexts(OptionTagOpenContext.class);
3162                }
3163                public OptionTagOpenContext optionTagOpen(int i) {
3164                        return getRuleContext(OptionTagOpenContext.class,i);
3165                }
3166                public List<TbodyTagOpenContext> tbodyTagOpen() {
3167                        return getRuleContexts(TbodyTagOpenContext.class);
3168                }
3169                public TbodyTagOpenContext tbodyTagOpen(int i) {
3170                        return getRuleContext(TbodyTagOpenContext.class,i);
3171                }
3172                public List<TheadTagOpenContext> theadTagOpen() {
3173                        return getRuleContexts(TheadTagOpenContext.class);
3174                }
3175                public TheadTagOpenContext theadTagOpen(int i) {
3176                        return getRuleContext(TheadTagOpenContext.class,i);
3177                }
3178                public List<TfootTagOpenContext> tfootTagOpen() {
3179                        return getRuleContexts(TfootTagOpenContext.class);
3180                }
3181                public TfootTagOpenContext tfootTagOpen(int i) {
3182                        return getRuleContext(TfootTagOpenContext.class,i);
3183                }
3184                public List<HtmlCommentContext> htmlComment() {
3185                        return getRuleContexts(HtmlCommentContext.class);
3186                }
3187                public HtmlCommentContext htmlComment(int i) {
3188                        return getRuleContext(HtmlCommentContext.class,i);
3189                }
3190                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3191                public TerminalNode CDATA(int i) {
3192                        return getToken(JavadocParser.CDATA, i);
3193                }
3194                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3195                public TerminalNode NEWLINE(int i) {
3196                        return getToken(JavadocParser.NEWLINE, i);
3197                }
3198                public List<TextContext> text() {
3199                        return getRuleContexts(TextContext.class);
3200                }
3201                public TextContext text(int i) {
3202                        return getRuleContext(TextContext.class,i);
3203                }
3204                public List<JavadocInlineTagContext> javadocInlineTag() {
3205                        return getRuleContexts(JavadocInlineTagContext.class);
3206                }
3207                public JavadocInlineTagContext javadocInlineTag(int i) {
3208                        return getRuleContext(JavadocInlineTagContext.class,i);
3209                }
3210                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3211                public TerminalNode LEADING_ASTERISK(int i) {
3212                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3213                }
3214                public TrContext(ParserRuleContext parent, int invokingState) {
3215                        super(parent, invokingState);
3216                }
3217                @Override public int getRuleIndex() { return RULE_tr; }
3218                @Override
3219                public void enterRule(ParseTreeListener listener) {
3220                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this);
3221                }
3222                @Override
3223                public void exitRule(ParseTreeListener listener) {
3224                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this);
3225                }
3226                @Override
3227                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3228                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this);
3229                        else return visitor.visitChildren(this);
3230                }
3231        }
3232
3233        public final TrContext tr() throws RecognitionException {
3234                TrContext _localctx = new TrContext(_ctx, getState());
3235                enterRule(_localctx, 28, RULE_tr);
3236                try {
3237                        int _alt;
3238                        enterOuterAlt(_localctx, 1);
3239                        {
3240                        setState(468);
3241                        trTagOpen();
3242                        setState(508);
3243                        _errHandler.sync(this);
3244                        _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3245                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3246                                if ( _alt==1 ) {
3247                                        {
3248                                        setState(506);
3249                                        _errHandler.sync(this);
3250                                        switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
3251                                        case 1:
3252                                                {
3253                                                setState(469);
3254                                                htmlTag();
3255                                                }
3256                                                break;
3257                                        case 2:
3258                                                {
3259                                                setState(470);
3260                                                singletonTag();
3261                                                }
3262                                                break;
3263                                        case 3:
3264                                                {
3265                                                setState(471);
3266                                                paragraph();
3267                                                }
3268                                                break;
3269                                        case 4:
3270                                                {
3271                                                setState(472);
3272                                                li();
3273                                                }
3274                                                break;
3275                                        case 5:
3276                                                {
3277                                                setState(473);
3278                                                td();
3279                                                }
3280                                                break;
3281                                        case 6:
3282                                                {
3283                                                setState(474);
3284                                                th();
3285                                                }
3286                                                break;
3287                                        case 7:
3288                                                {
3289                                                setState(475);
3290                                                body();
3291                                                }
3292                                                break;
3293                                        case 8:
3294                                                {
3295                                                setState(476);
3296                                                colgroup();
3297                                                }
3298                                                break;
3299                                        case 9:
3300                                                {
3301                                                setState(477);
3302                                                dd();
3303                                                }
3304                                                break;
3305                                        case 10:
3306                                                {
3307                                                setState(478);
3308                                                dt();
3309                                                }
3310                                                break;
3311                                        case 11:
3312                                                {
3313                                                setState(479);
3314                                                head();
3315                                                }
3316                                                break;
3317                                        case 12:
3318                                                {
3319                                                setState(480);
3320                                                html();
3321                                                }
3322                                                break;
3323                                        case 13:
3324                                                {
3325                                                setState(481);
3326                                                option();
3327                                                }
3328                                                break;
3329                                        case 14:
3330                                                {
3331                                                setState(482);
3332                                                tbody();
3333                                                }
3334                                                break;
3335                                        case 15:
3336                                                {
3337                                                setState(483);
3338                                                thead();
3339                                                }
3340                                                break;
3341                                        case 16:
3342                                                {
3343                                                setState(484);
3344                                                tfoot();
3345                                                }
3346                                                break;
3347                                        case 17:
3348                                                {
3349                                                setState(485);
3350                                                pTagOpen();
3351                                                }
3352                                                break;
3353                                        case 18:
3354                                                {
3355                                                setState(486);
3356                                                liTagOpen();
3357                                                }
3358                                                break;
3359                                        case 19:
3360                                                {
3361                                                setState(487);
3362                                                tdTagOpen();
3363                                                }
3364                                                break;
3365                                        case 20:
3366                                                {
3367                                                setState(488);
3368                                                thTagOpen();
3369                                                }
3370                                                break;
3371                                        case 21:
3372                                                {
3373                                                setState(489);
3374                                                bodyTagOpen();
3375                                                }
3376                                                break;
3377                                        case 22:
3378                                                {
3379                                                setState(490);
3380                                                colgroupTagOpen();
3381                                                }
3382                                                break;
3383                                        case 23:
3384                                                {
3385                                                setState(491);
3386                                                ddTagOpen();
3387                                                }
3388                                                break;
3389                                        case 24:
3390                                                {
3391                                                setState(492);
3392                                                dtTagOpen();
3393                                                }
3394                                                break;
3395                                        case 25:
3396                                                {
3397                                                setState(493);
3398                                                headTagOpen();
3399                                                }
3400                                                break;
3401                                        case 26:
3402                                                {
3403                                                setState(494);
3404                                                htmlTagOpen();
3405                                                }
3406                                                break;
3407                                        case 27:
3408                                                {
3409                                                setState(495);
3410                                                optionTagOpen();
3411                                                }
3412                                                break;
3413                                        case 28:
3414                                                {
3415                                                setState(496);
3416                                                tbodyTagOpen();
3417                                                }
3418                                                break;
3419                                        case 29:
3420                                                {
3421                                                setState(497);
3422                                                theadTagOpen();
3423                                                }
3424                                                break;
3425                                        case 30:
3426                                                {
3427                                                setState(498);
3428                                                tfootTagOpen();
3429                                                }
3430                                                break;
3431                                        case 31:
3432                                                {
3433                                                {
3434                                                setState(499);
3435                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
3436                                                setState(500);
3437                                                match(LEADING_ASTERISK);
3438                                                }
3439                                                }
3440                                                break;
3441                                        case 32:
3442                                                {
3443                                                setState(501);
3444                                                htmlComment();
3445                                                }
3446                                                break;
3447                                        case 33:
3448                                                {
3449                                                setState(502);
3450                                                match(CDATA);
3451                                                }
3452                                                break;
3453                                        case 34:
3454                                                {
3455                                                setState(503);
3456                                                match(NEWLINE);
3457                                                }
3458                                                break;
3459                                        case 35:
3460                                                {
3461                                                setState(504);
3462                                                text();
3463                                                }
3464                                                break;
3465                                        case 36:
3466                                                {
3467                                                setState(505);
3468                                                javadocInlineTag();
3469                                                }
3470                                                break;
3471                                        }
3472                                        } 
3473                                }
3474                                setState(510);
3475                                _errHandler.sync(this);
3476                                _alt = getInterpreter().adaptivePredict(_input,31,_ctx);
3477                        }
3478                        setState(511);
3479                        trTagClose();
3480                        }
3481                }
3482                catch (RecognitionException re) {
3483                        _localctx.exception = re;
3484                        _errHandler.reportError(this, re);
3485                        _errHandler.recover(this, re);
3486                }
3487                finally {
3488                        exitRule();
3489                }
3490                return _localctx;
3491        }
3492
3493        public static class TdTagOpenContext extends ParserRuleContext {
3494                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3495                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3496                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3497                public List<AttributeContext> attribute() {
3498                        return getRuleContexts(AttributeContext.class);
3499                }
3500                public AttributeContext attribute(int i) {
3501                        return getRuleContext(AttributeContext.class,i);
3502                }
3503                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3504                public TerminalNode NEWLINE(int i) {
3505                        return getToken(JavadocParser.NEWLINE, i);
3506                }
3507                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3508                public TerminalNode LEADING_ASTERISK(int i) {
3509                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3510                }
3511                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3512                public TerminalNode WS(int i) {
3513                        return getToken(JavadocParser.WS, i);
3514                }
3515                public TdTagOpenContext(ParserRuleContext parent, int invokingState) {
3516                        super(parent, invokingState);
3517                }
3518                @Override public int getRuleIndex() { return RULE_tdTagOpen; }
3519                @Override
3520                public void enterRule(ParseTreeListener listener) {
3521                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this);
3522                }
3523                @Override
3524                public void exitRule(ParseTreeListener listener) {
3525                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this);
3526                }
3527                @Override
3528                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3529                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this);
3530                        else return visitor.visitChildren(this);
3531                }
3532        }
3533
3534        public final TdTagOpenContext tdTagOpen() throws RecognitionException {
3535                TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState());
3536                enterRule(_localctx, 30, RULE_tdTagOpen);
3537                int _la;
3538                try {
3539                        enterOuterAlt(_localctx, 1);
3540                        {
3541                        setState(513);
3542                        match(OPEN);
3543                        setState(514);
3544                        match(TD_HTML_TAG_NAME);
3545                        setState(521);
3546                        _errHandler.sync(this);
3547                        _la = _input.LA(1);
3548                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
3549                                {
3550                                setState(519);
3551                                switch (_input.LA(1)) {
3552                                case HTML_TAG_NAME:
3553                                        {
3554                                        setState(515);
3555                                        attribute();
3556                                        }
3557                                        break;
3558                                case NEWLINE:
3559                                        {
3560                                        setState(516);
3561                                        match(NEWLINE);
3562                                        }
3563                                        break;
3564                                case LEADING_ASTERISK:
3565                                        {
3566                                        setState(517);
3567                                        match(LEADING_ASTERISK);
3568                                        }
3569                                        break;
3570                                case WS:
3571                                        {
3572                                        setState(518);
3573                                        match(WS);
3574                                        }
3575                                        break;
3576                                default:
3577                                        throw new NoViableAltException(this);
3578                                }
3579                                }
3580                                setState(523);
3581                                _errHandler.sync(this);
3582                                _la = _input.LA(1);
3583                        }
3584                        setState(524);
3585                        match(CLOSE);
3586                        }
3587                }
3588                catch (RecognitionException re) {
3589                        _localctx.exception = re;
3590                        _errHandler.reportError(this, re);
3591                        _errHandler.recover(this, re);
3592                }
3593                finally {
3594                        exitRule();
3595                }
3596                return _localctx;
3597        }
3598
3599        public static class TdTagCloseContext extends ParserRuleContext {
3600                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
3601                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
3602                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
3603                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
3604                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3605                public TerminalNode NEWLINE(int i) {
3606                        return getToken(JavadocParser.NEWLINE, i);
3607                }
3608                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3609                public TerminalNode LEADING_ASTERISK(int i) {
3610                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3611                }
3612                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
3613                public TerminalNode WS(int i) {
3614                        return getToken(JavadocParser.WS, i);
3615                }
3616                public TdTagCloseContext(ParserRuleContext parent, int invokingState) {
3617                        super(parent, invokingState);
3618                }
3619                @Override public int getRuleIndex() { return RULE_tdTagClose; }
3620                @Override
3621                public void enterRule(ParseTreeListener listener) {
3622                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this);
3623                }
3624                @Override
3625                public void exitRule(ParseTreeListener listener) {
3626                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this);
3627                }
3628                @Override
3629                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3630                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this);
3631                        else return visitor.visitChildren(this);
3632                }
3633        }
3634
3635        public final TdTagCloseContext tdTagClose() throws RecognitionException {
3636                TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState());
3637                enterRule(_localctx, 32, RULE_tdTagClose);
3638                int _la;
3639                try {
3640                        enterOuterAlt(_localctx, 1);
3641                        {
3642                        setState(526);
3643                        match(OPEN);
3644                        setState(527);
3645                        match(SLASH);
3646                        setState(528);
3647                        match(TD_HTML_TAG_NAME);
3648                        setState(532);
3649                        _errHandler.sync(this);
3650                        _la = _input.LA(1);
3651                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
3652                                {
3653                                {
3654                                setState(529);
3655                                _la = _input.LA(1);
3656                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
3657                                _errHandler.recoverInline(this);
3658                                } else {
3659                                        consume();
3660                                }
3661                                }
3662                                }
3663                                setState(534);
3664                                _errHandler.sync(this);
3665                                _la = _input.LA(1);
3666                        }
3667                        setState(535);
3668                        match(CLOSE);
3669                        }
3670                }
3671                catch (RecognitionException re) {
3672                        _localctx.exception = re;
3673                        _errHandler.reportError(this, re);
3674                        _errHandler.recover(this, re);
3675                }
3676                finally {
3677                        exitRule();
3678                }
3679                return _localctx;
3680        }
3681
3682        public static class TdContext extends ParserRuleContext {
3683                public List<TdTagOpenContext> tdTagOpen() {
3684                        return getRuleContexts(TdTagOpenContext.class);
3685                }
3686                public TdTagOpenContext tdTagOpen(int i) {
3687                        return getRuleContext(TdTagOpenContext.class,i);
3688                }
3689                public TdTagCloseContext tdTagClose() {
3690                        return getRuleContext(TdTagCloseContext.class,0);
3691                }
3692                public List<HtmlTagContext> htmlTag() {
3693                        return getRuleContexts(HtmlTagContext.class);
3694                }
3695                public HtmlTagContext htmlTag(int i) {
3696                        return getRuleContext(HtmlTagContext.class,i);
3697                }
3698                public List<SingletonTagContext> singletonTag() {
3699                        return getRuleContexts(SingletonTagContext.class);
3700                }
3701                public SingletonTagContext singletonTag(int i) {
3702                        return getRuleContext(SingletonTagContext.class,i);
3703                }
3704                public List<ParagraphContext> paragraph() {
3705                        return getRuleContexts(ParagraphContext.class);
3706                }
3707                public ParagraphContext paragraph(int i) {
3708                        return getRuleContext(ParagraphContext.class,i);
3709                }
3710                public List<LiContext> li() {
3711                        return getRuleContexts(LiContext.class);
3712                }
3713                public LiContext li(int i) {
3714                        return getRuleContext(LiContext.class,i);
3715                }
3716                public List<TrContext> tr() {
3717                        return getRuleContexts(TrContext.class);
3718                }
3719                public TrContext tr(int i) {
3720                        return getRuleContext(TrContext.class,i);
3721                }
3722                public List<ThContext> th() {
3723                        return getRuleContexts(ThContext.class);
3724                }
3725                public ThContext th(int i) {
3726                        return getRuleContext(ThContext.class,i);
3727                }
3728                public List<BodyContext> body() {
3729                        return getRuleContexts(BodyContext.class);
3730                }
3731                public BodyContext body(int i) {
3732                        return getRuleContext(BodyContext.class,i);
3733                }
3734                public List<ColgroupContext> colgroup() {
3735                        return getRuleContexts(ColgroupContext.class);
3736                }
3737                public ColgroupContext colgroup(int i) {
3738                        return getRuleContext(ColgroupContext.class,i);
3739                }
3740                public List<DdContext> dd() {
3741                        return getRuleContexts(DdContext.class);
3742                }
3743                public DdContext dd(int i) {
3744                        return getRuleContext(DdContext.class,i);
3745                }
3746                public List<DtContext> dt() {
3747                        return getRuleContexts(DtContext.class);
3748                }
3749                public DtContext dt(int i) {
3750                        return getRuleContext(DtContext.class,i);
3751                }
3752                public List<HeadContext> head() {
3753                        return getRuleContexts(HeadContext.class);
3754                }
3755                public HeadContext head(int i) {
3756                        return getRuleContext(HeadContext.class,i);
3757                }
3758                public List<HtmlContext> html() {
3759                        return getRuleContexts(HtmlContext.class);
3760                }
3761                public HtmlContext html(int i) {
3762                        return getRuleContext(HtmlContext.class,i);
3763                }
3764                public List<OptionContext> option() {
3765                        return getRuleContexts(OptionContext.class);
3766                }
3767                public OptionContext option(int i) {
3768                        return getRuleContext(OptionContext.class,i);
3769                }
3770                public List<TbodyContext> tbody() {
3771                        return getRuleContexts(TbodyContext.class);
3772                }
3773                public TbodyContext tbody(int i) {
3774                        return getRuleContext(TbodyContext.class,i);
3775                }
3776                public List<TheadContext> thead() {
3777                        return getRuleContexts(TheadContext.class);
3778                }
3779                public TheadContext thead(int i) {
3780                        return getRuleContext(TheadContext.class,i);
3781                }
3782                public List<TfootContext> tfoot() {
3783                        return getRuleContexts(TfootContext.class);
3784                }
3785                public TfootContext tfoot(int i) {
3786                        return getRuleContext(TfootContext.class,i);
3787                }
3788                public List<PTagOpenContext> pTagOpen() {
3789                        return getRuleContexts(PTagOpenContext.class);
3790                }
3791                public PTagOpenContext pTagOpen(int i) {
3792                        return getRuleContext(PTagOpenContext.class,i);
3793                }
3794                public List<LiTagOpenContext> liTagOpen() {
3795                        return getRuleContexts(LiTagOpenContext.class);
3796                }
3797                public LiTagOpenContext liTagOpen(int i) {
3798                        return getRuleContext(LiTagOpenContext.class,i);
3799                }
3800                public List<ThTagOpenContext> thTagOpen() {
3801                        return getRuleContexts(ThTagOpenContext.class);
3802                }
3803                public ThTagOpenContext thTagOpen(int i) {
3804                        return getRuleContext(ThTagOpenContext.class,i);
3805                }
3806                public List<BodyTagOpenContext> bodyTagOpen() {
3807                        return getRuleContexts(BodyTagOpenContext.class);
3808                }
3809                public BodyTagOpenContext bodyTagOpen(int i) {
3810                        return getRuleContext(BodyTagOpenContext.class,i);
3811                }
3812                public List<ColgroupTagOpenContext> colgroupTagOpen() {
3813                        return getRuleContexts(ColgroupTagOpenContext.class);
3814                }
3815                public ColgroupTagOpenContext colgroupTagOpen(int i) {
3816                        return getRuleContext(ColgroupTagOpenContext.class,i);
3817                }
3818                public List<DdTagOpenContext> ddTagOpen() {
3819                        return getRuleContexts(DdTagOpenContext.class);
3820                }
3821                public DdTagOpenContext ddTagOpen(int i) {
3822                        return getRuleContext(DdTagOpenContext.class,i);
3823                }
3824                public List<DtTagOpenContext> dtTagOpen() {
3825                        return getRuleContexts(DtTagOpenContext.class);
3826                }
3827                public DtTagOpenContext dtTagOpen(int i) {
3828                        return getRuleContext(DtTagOpenContext.class,i);
3829                }
3830                public List<HeadTagOpenContext> headTagOpen() {
3831                        return getRuleContexts(HeadTagOpenContext.class);
3832                }
3833                public HeadTagOpenContext headTagOpen(int i) {
3834                        return getRuleContext(HeadTagOpenContext.class,i);
3835                }
3836                public List<HtmlTagOpenContext> htmlTagOpen() {
3837                        return getRuleContexts(HtmlTagOpenContext.class);
3838                }
3839                public HtmlTagOpenContext htmlTagOpen(int i) {
3840                        return getRuleContext(HtmlTagOpenContext.class,i);
3841                }
3842                public List<OptionTagOpenContext> optionTagOpen() {
3843                        return getRuleContexts(OptionTagOpenContext.class);
3844                }
3845                public OptionTagOpenContext optionTagOpen(int i) {
3846                        return getRuleContext(OptionTagOpenContext.class,i);
3847                }
3848                public List<TbodyTagOpenContext> tbodyTagOpen() {
3849                        return getRuleContexts(TbodyTagOpenContext.class);
3850                }
3851                public TbodyTagOpenContext tbodyTagOpen(int i) {
3852                        return getRuleContext(TbodyTagOpenContext.class,i);
3853                }
3854                public List<TheadTagOpenContext> theadTagOpen() {
3855                        return getRuleContexts(TheadTagOpenContext.class);
3856                }
3857                public TheadTagOpenContext theadTagOpen(int i) {
3858                        return getRuleContext(TheadTagOpenContext.class,i);
3859                }
3860                public List<TfootTagOpenContext> tfootTagOpen() {
3861                        return getRuleContexts(TfootTagOpenContext.class);
3862                }
3863                public TfootTagOpenContext tfootTagOpen(int i) {
3864                        return getRuleContext(TfootTagOpenContext.class,i);
3865                }
3866                public List<HtmlCommentContext> htmlComment() {
3867                        return getRuleContexts(HtmlCommentContext.class);
3868                }
3869                public HtmlCommentContext htmlComment(int i) {
3870                        return getRuleContext(HtmlCommentContext.class,i);
3871                }
3872                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
3873                public TerminalNode CDATA(int i) {
3874                        return getToken(JavadocParser.CDATA, i);
3875                }
3876                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
3877                public TerminalNode NEWLINE(int i) {
3878                        return getToken(JavadocParser.NEWLINE, i);
3879                }
3880                public List<TextContext> text() {
3881                        return getRuleContexts(TextContext.class);
3882                }
3883                public TextContext text(int i) {
3884                        return getRuleContext(TextContext.class,i);
3885                }
3886                public List<JavadocInlineTagContext> javadocInlineTag() {
3887                        return getRuleContexts(JavadocInlineTagContext.class);
3888                }
3889                public JavadocInlineTagContext javadocInlineTag(int i) {
3890                        return getRuleContext(JavadocInlineTagContext.class,i);
3891                }
3892                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
3893                public TerminalNode LEADING_ASTERISK(int i) {
3894                        return getToken(JavadocParser.LEADING_ASTERISK, i);
3895                }
3896                public TdContext(ParserRuleContext parent, int invokingState) {
3897                        super(parent, invokingState);
3898                }
3899                @Override public int getRuleIndex() { return RULE_td; }
3900                @Override
3901                public void enterRule(ParseTreeListener listener) {
3902                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this);
3903                }
3904                @Override
3905                public void exitRule(ParseTreeListener listener) {
3906                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this);
3907                }
3908                @Override
3909                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
3910                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this);
3911                        else return visitor.visitChildren(this);
3912                }
3913        }
3914
3915        public final TdContext td() throws RecognitionException {
3916                TdContext _localctx = new TdContext(_ctx, getState());
3917                enterRule(_localctx, 34, RULE_td);
3918                try {
3919                        int _alt;
3920                        enterOuterAlt(_localctx, 1);
3921                        {
3922                        setState(537);
3923                        tdTagOpen();
3924                        setState(577);
3925                        _errHandler.sync(this);
3926                        _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
3927                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3928                                if ( _alt==1 ) {
3929                                        {
3930                                        setState(575);
3931                                        _errHandler.sync(this);
3932                                        switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
3933                                        case 1:
3934                                                {
3935                                                setState(538);
3936                                                htmlTag();
3937                                                }
3938                                                break;
3939                                        case 2:
3940                                                {
3941                                                setState(539);
3942                                                singletonTag();
3943                                                }
3944                                                break;
3945                                        case 3:
3946                                                {
3947                                                setState(540);
3948                                                paragraph();
3949                                                }
3950                                                break;
3951                                        case 4:
3952                                                {
3953                                                setState(541);
3954                                                li();
3955                                                }
3956                                                break;
3957                                        case 5:
3958                                                {
3959                                                setState(542);
3960                                                tr();
3961                                                }
3962                                                break;
3963                                        case 6:
3964                                                {
3965                                                setState(543);
3966                                                th();
3967                                                }
3968                                                break;
3969                                        case 7:
3970                                                {
3971                                                setState(544);
3972                                                body();
3973                                                }
3974                                                break;
3975                                        case 8:
3976                                                {
3977                                                setState(545);
3978                                                colgroup();
3979                                                }
3980                                                break;
3981                                        case 9:
3982                                                {
3983                                                setState(546);
3984                                                dd();
3985                                                }
3986                                                break;
3987                                        case 10:
3988                                                {
3989                                                setState(547);
3990                                                dt();
3991                                                }
3992                                                break;
3993                                        case 11:
3994                                                {
3995                                                setState(548);
3996                                                head();
3997                                                }
3998                                                break;
3999                                        case 12:
4000                                                {
4001                                                setState(549);
4002                                                html();
4003                                                }
4004                                                break;
4005                                        case 13:
4006                                                {
4007                                                setState(550);
4008                                                option();
4009                                                }
4010                                                break;
4011                                        case 14:
4012                                                {
4013                                                setState(551);
4014                                                tbody();
4015                                                }
4016                                                break;
4017                                        case 15:
4018                                                {
4019                                                setState(552);
4020                                                thead();
4021                                                }
4022                                                break;
4023                                        case 16:
4024                                                {
4025                                                setState(553);
4026                                                tfoot();
4027                                                }
4028                                                break;
4029                                        case 17:
4030                                                {
4031                                                setState(554);
4032                                                pTagOpen();
4033                                                }
4034                                                break;
4035                                        case 18:
4036                                                {
4037                                                setState(555);
4038                                                liTagOpen();
4039                                                }
4040                                                break;
4041                                        case 19:
4042                                                {
4043                                                setState(556);
4044                                                tdTagOpen();
4045                                                }
4046                                                break;
4047                                        case 20:
4048                                                {
4049                                                setState(557);
4050                                                thTagOpen();
4051                                                }
4052                                                break;
4053                                        case 21:
4054                                                {
4055                                                setState(558);
4056                                                bodyTagOpen();
4057                                                }
4058                                                break;
4059                                        case 22:
4060                                                {
4061                                                setState(559);
4062                                                colgroupTagOpen();
4063                                                }
4064                                                break;
4065                                        case 23:
4066                                                {
4067                                                setState(560);
4068                                                ddTagOpen();
4069                                                }
4070                                                break;
4071                                        case 24:
4072                                                {
4073                                                setState(561);
4074                                                dtTagOpen();
4075                                                }
4076                                                break;
4077                                        case 25:
4078                                                {
4079                                                setState(562);
4080                                                headTagOpen();
4081                                                }
4082                                                break;
4083                                        case 26:
4084                                                {
4085                                                setState(563);
4086                                                htmlTagOpen();
4087                                                }
4088                                                break;
4089                                        case 27:
4090                                                {
4091                                                setState(564);
4092                                                optionTagOpen();
4093                                                }
4094                                                break;
4095                                        case 28:
4096                                                {
4097                                                setState(565);
4098                                                tbodyTagOpen();
4099                                                }
4100                                                break;
4101                                        case 29:
4102                                                {
4103                                                setState(566);
4104                                                theadTagOpen();
4105                                                }
4106                                                break;
4107                                        case 30:
4108                                                {
4109                                                setState(567);
4110                                                tfootTagOpen();
4111                                                }
4112                                                break;
4113                                        case 31:
4114                                                {
4115                                                {
4116                                                setState(568);
4117                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4118                                                setState(569);
4119                                                match(LEADING_ASTERISK);
4120                                                }
4121                                                }
4122                                                break;
4123                                        case 32:
4124                                                {
4125                                                setState(570);
4126                                                htmlComment();
4127                                                }
4128                                                break;
4129                                        case 33:
4130                                                {
4131                                                setState(571);
4132                                                match(CDATA);
4133                                                }
4134                                                break;
4135                                        case 34:
4136                                                {
4137                                                setState(572);
4138                                                match(NEWLINE);
4139                                                }
4140                                                break;
4141                                        case 35:
4142                                                {
4143                                                setState(573);
4144                                                text();
4145                                                }
4146                                                break;
4147                                        case 36:
4148                                                {
4149                                                setState(574);
4150                                                javadocInlineTag();
4151                                                }
4152                                                break;
4153                                        }
4154                                        } 
4155                                }
4156                                setState(579);
4157                                _errHandler.sync(this);
4158                                _alt = getInterpreter().adaptivePredict(_input,36,_ctx);
4159                        }
4160                        setState(580);
4161                        tdTagClose();
4162                        }
4163                }
4164                catch (RecognitionException re) {
4165                        _localctx.exception = re;
4166                        _errHandler.reportError(this, re);
4167                        _errHandler.recover(this, re);
4168                }
4169                finally {
4170                        exitRule();
4171                }
4172                return _localctx;
4173        }
4174
4175        public static class ThTagOpenContext extends ParserRuleContext {
4176                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4177                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4178                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4179                public List<AttributeContext> attribute() {
4180                        return getRuleContexts(AttributeContext.class);
4181                }
4182                public AttributeContext attribute(int i) {
4183                        return getRuleContext(AttributeContext.class,i);
4184                }
4185                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4186                public TerminalNode NEWLINE(int i) {
4187                        return getToken(JavadocParser.NEWLINE, i);
4188                }
4189                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4190                public TerminalNode LEADING_ASTERISK(int i) {
4191                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4192                }
4193                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4194                public TerminalNode WS(int i) {
4195                        return getToken(JavadocParser.WS, i);
4196                }
4197                public ThTagOpenContext(ParserRuleContext parent, int invokingState) {
4198                        super(parent, invokingState);
4199                }
4200                @Override public int getRuleIndex() { return RULE_thTagOpen; }
4201                @Override
4202                public void enterRule(ParseTreeListener listener) {
4203                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this);
4204                }
4205                @Override
4206                public void exitRule(ParseTreeListener listener) {
4207                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this);
4208                }
4209                @Override
4210                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4211                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this);
4212                        else return visitor.visitChildren(this);
4213                }
4214        }
4215
4216        public final ThTagOpenContext thTagOpen() throws RecognitionException {
4217                ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState());
4218                enterRule(_localctx, 36, RULE_thTagOpen);
4219                int _la;
4220                try {
4221                        enterOuterAlt(_localctx, 1);
4222                        {
4223                        setState(582);
4224                        match(OPEN);
4225                        setState(583);
4226                        match(TH_HTML_TAG_NAME);
4227                        setState(590);
4228                        _errHandler.sync(this);
4229                        _la = _input.LA(1);
4230                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4231                                {
4232                                setState(588);
4233                                switch (_input.LA(1)) {
4234                                case HTML_TAG_NAME:
4235                                        {
4236                                        setState(584);
4237                                        attribute();
4238                                        }
4239                                        break;
4240                                case NEWLINE:
4241                                        {
4242                                        setState(585);
4243                                        match(NEWLINE);
4244                                        }
4245                                        break;
4246                                case LEADING_ASTERISK:
4247                                        {
4248                                        setState(586);
4249                                        match(LEADING_ASTERISK);
4250                                        }
4251                                        break;
4252                                case WS:
4253                                        {
4254                                        setState(587);
4255                                        match(WS);
4256                                        }
4257                                        break;
4258                                default:
4259                                        throw new NoViableAltException(this);
4260                                }
4261                                }
4262                                setState(592);
4263                                _errHandler.sync(this);
4264                                _la = _input.LA(1);
4265                        }
4266                        setState(593);
4267                        match(CLOSE);
4268                        }
4269                }
4270                catch (RecognitionException re) {
4271                        _localctx.exception = re;
4272                        _errHandler.reportError(this, re);
4273                        _errHandler.recover(this, re);
4274                }
4275                finally {
4276                        exitRule();
4277                }
4278                return _localctx;
4279        }
4280
4281        public static class ThTagCloseContext extends ParserRuleContext {
4282                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4283                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4284                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
4285                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4286                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4287                public TerminalNode NEWLINE(int i) {
4288                        return getToken(JavadocParser.NEWLINE, i);
4289                }
4290                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4291                public TerminalNode LEADING_ASTERISK(int i) {
4292                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4293                }
4294                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4295                public TerminalNode WS(int i) {
4296                        return getToken(JavadocParser.WS, i);
4297                }
4298                public ThTagCloseContext(ParserRuleContext parent, int invokingState) {
4299                        super(parent, invokingState);
4300                }
4301                @Override public int getRuleIndex() { return RULE_thTagClose; }
4302                @Override
4303                public void enterRule(ParseTreeListener listener) {
4304                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this);
4305                }
4306                @Override
4307                public void exitRule(ParseTreeListener listener) {
4308                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this);
4309                }
4310                @Override
4311                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4312                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this);
4313                        else return visitor.visitChildren(this);
4314                }
4315        }
4316
4317        public final ThTagCloseContext thTagClose() throws RecognitionException {
4318                ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState());
4319                enterRule(_localctx, 38, RULE_thTagClose);
4320                int _la;
4321                try {
4322                        enterOuterAlt(_localctx, 1);
4323                        {
4324                        setState(595);
4325                        match(OPEN);
4326                        setState(596);
4327                        match(SLASH);
4328                        setState(597);
4329                        match(TH_HTML_TAG_NAME);
4330                        setState(601);
4331                        _errHandler.sync(this);
4332                        _la = _input.LA(1);
4333                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
4334                                {
4335                                {
4336                                setState(598);
4337                                _la = _input.LA(1);
4338                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
4339                                _errHandler.recoverInline(this);
4340                                } else {
4341                                        consume();
4342                                }
4343                                }
4344                                }
4345                                setState(603);
4346                                _errHandler.sync(this);
4347                                _la = _input.LA(1);
4348                        }
4349                        setState(604);
4350                        match(CLOSE);
4351                        }
4352                }
4353                catch (RecognitionException re) {
4354                        _localctx.exception = re;
4355                        _errHandler.reportError(this, re);
4356                        _errHandler.recover(this, re);
4357                }
4358                finally {
4359                        exitRule();
4360                }
4361                return _localctx;
4362        }
4363
4364        public static class ThContext extends ParserRuleContext {
4365                public ThTagOpenContext thTagOpen() {
4366                        return getRuleContext(ThTagOpenContext.class,0);
4367                }
4368                public ThTagCloseContext thTagClose() {
4369                        return getRuleContext(ThTagCloseContext.class,0);
4370                }
4371                public List<HtmlTagContext> htmlTag() {
4372                        return getRuleContexts(HtmlTagContext.class);
4373                }
4374                public HtmlTagContext htmlTag(int i) {
4375                        return getRuleContext(HtmlTagContext.class,i);
4376                }
4377                public List<SingletonTagContext> singletonTag() {
4378                        return getRuleContexts(SingletonTagContext.class);
4379                }
4380                public SingletonTagContext singletonTag(int i) {
4381                        return getRuleContext(SingletonTagContext.class,i);
4382                }
4383                public List<ParagraphContext> paragraph() {
4384                        return getRuleContexts(ParagraphContext.class);
4385                }
4386                public ParagraphContext paragraph(int i) {
4387                        return getRuleContext(ParagraphContext.class,i);
4388                }
4389                public List<LiContext> li() {
4390                        return getRuleContexts(LiContext.class);
4391                }
4392                public LiContext li(int i) {
4393                        return getRuleContext(LiContext.class,i);
4394                }
4395                public List<TrContext> tr() {
4396                        return getRuleContexts(TrContext.class);
4397                }
4398                public TrContext tr(int i) {
4399                        return getRuleContext(TrContext.class,i);
4400                }
4401                public List<TdContext> td() {
4402                        return getRuleContexts(TdContext.class);
4403                }
4404                public TdContext td(int i) {
4405                        return getRuleContext(TdContext.class,i);
4406                }
4407                public List<BodyContext> body() {
4408                        return getRuleContexts(BodyContext.class);
4409                }
4410                public BodyContext body(int i) {
4411                        return getRuleContext(BodyContext.class,i);
4412                }
4413                public List<ColgroupContext> colgroup() {
4414                        return getRuleContexts(ColgroupContext.class);
4415                }
4416                public ColgroupContext colgroup(int i) {
4417                        return getRuleContext(ColgroupContext.class,i);
4418                }
4419                public List<DdContext> dd() {
4420                        return getRuleContexts(DdContext.class);
4421                }
4422                public DdContext dd(int i) {
4423                        return getRuleContext(DdContext.class,i);
4424                }
4425                public List<DtContext> dt() {
4426                        return getRuleContexts(DtContext.class);
4427                }
4428                public DtContext dt(int i) {
4429                        return getRuleContext(DtContext.class,i);
4430                }
4431                public List<HeadContext> head() {
4432                        return getRuleContexts(HeadContext.class);
4433                }
4434                public HeadContext head(int i) {
4435                        return getRuleContext(HeadContext.class,i);
4436                }
4437                public List<HtmlContext> html() {
4438                        return getRuleContexts(HtmlContext.class);
4439                }
4440                public HtmlContext html(int i) {
4441                        return getRuleContext(HtmlContext.class,i);
4442                }
4443                public List<OptionContext> option() {
4444                        return getRuleContexts(OptionContext.class);
4445                }
4446                public OptionContext option(int i) {
4447                        return getRuleContext(OptionContext.class,i);
4448                }
4449                public List<TbodyContext> tbody() {
4450                        return getRuleContexts(TbodyContext.class);
4451                }
4452                public TbodyContext tbody(int i) {
4453                        return getRuleContext(TbodyContext.class,i);
4454                }
4455                public List<TheadContext> thead() {
4456                        return getRuleContexts(TheadContext.class);
4457                }
4458                public TheadContext thead(int i) {
4459                        return getRuleContext(TheadContext.class,i);
4460                }
4461                public List<TfootContext> tfoot() {
4462                        return getRuleContexts(TfootContext.class);
4463                }
4464                public TfootContext tfoot(int i) {
4465                        return getRuleContext(TfootContext.class,i);
4466                }
4467                public List<PTagOpenContext> pTagOpen() {
4468                        return getRuleContexts(PTagOpenContext.class);
4469                }
4470                public PTagOpenContext pTagOpen(int i) {
4471                        return getRuleContext(PTagOpenContext.class,i);
4472                }
4473                public List<LiTagOpenContext> liTagOpen() {
4474                        return getRuleContexts(LiTagOpenContext.class);
4475                }
4476                public LiTagOpenContext liTagOpen(int i) {
4477                        return getRuleContext(LiTagOpenContext.class,i);
4478                }
4479                public List<TrTagOpenContext> trTagOpen() {
4480                        return getRuleContexts(TrTagOpenContext.class);
4481                }
4482                public TrTagOpenContext trTagOpen(int i) {
4483                        return getRuleContext(TrTagOpenContext.class,i);
4484                }
4485                public List<TdTagOpenContext> tdTagOpen() {
4486                        return getRuleContexts(TdTagOpenContext.class);
4487                }
4488                public TdTagOpenContext tdTagOpen(int i) {
4489                        return getRuleContext(TdTagOpenContext.class,i);
4490                }
4491                public List<BodyTagOpenContext> bodyTagOpen() {
4492                        return getRuleContexts(BodyTagOpenContext.class);
4493                }
4494                public BodyTagOpenContext bodyTagOpen(int i) {
4495                        return getRuleContext(BodyTagOpenContext.class,i);
4496                }
4497                public List<ColgroupTagOpenContext> colgroupTagOpen() {
4498                        return getRuleContexts(ColgroupTagOpenContext.class);
4499                }
4500                public ColgroupTagOpenContext colgroupTagOpen(int i) {
4501                        return getRuleContext(ColgroupTagOpenContext.class,i);
4502                }
4503                public List<DdTagOpenContext> ddTagOpen() {
4504                        return getRuleContexts(DdTagOpenContext.class);
4505                }
4506                public DdTagOpenContext ddTagOpen(int i) {
4507                        return getRuleContext(DdTagOpenContext.class,i);
4508                }
4509                public List<DtTagOpenContext> dtTagOpen() {
4510                        return getRuleContexts(DtTagOpenContext.class);
4511                }
4512                public DtTagOpenContext dtTagOpen(int i) {
4513                        return getRuleContext(DtTagOpenContext.class,i);
4514                }
4515                public List<HeadTagOpenContext> headTagOpen() {
4516                        return getRuleContexts(HeadTagOpenContext.class);
4517                }
4518                public HeadTagOpenContext headTagOpen(int i) {
4519                        return getRuleContext(HeadTagOpenContext.class,i);
4520                }
4521                public List<HtmlTagOpenContext> htmlTagOpen() {
4522                        return getRuleContexts(HtmlTagOpenContext.class);
4523                }
4524                public HtmlTagOpenContext htmlTagOpen(int i) {
4525                        return getRuleContext(HtmlTagOpenContext.class,i);
4526                }
4527                public List<OptionTagOpenContext> optionTagOpen() {
4528                        return getRuleContexts(OptionTagOpenContext.class);
4529                }
4530                public OptionTagOpenContext optionTagOpen(int i) {
4531                        return getRuleContext(OptionTagOpenContext.class,i);
4532                }
4533                public List<TbodyTagOpenContext> tbodyTagOpen() {
4534                        return getRuleContexts(TbodyTagOpenContext.class);
4535                }
4536                public TbodyTagOpenContext tbodyTagOpen(int i) {
4537                        return getRuleContext(TbodyTagOpenContext.class,i);
4538                }
4539                public List<TheadTagOpenContext> theadTagOpen() {
4540                        return getRuleContexts(TheadTagOpenContext.class);
4541                }
4542                public TheadTagOpenContext theadTagOpen(int i) {
4543                        return getRuleContext(TheadTagOpenContext.class,i);
4544                }
4545                public List<TfootTagOpenContext> tfootTagOpen() {
4546                        return getRuleContexts(TfootTagOpenContext.class);
4547                }
4548                public TfootTagOpenContext tfootTagOpen(int i) {
4549                        return getRuleContext(TfootTagOpenContext.class,i);
4550                }
4551                public List<HtmlCommentContext> htmlComment() {
4552                        return getRuleContexts(HtmlCommentContext.class);
4553                }
4554                public HtmlCommentContext htmlComment(int i) {
4555                        return getRuleContext(HtmlCommentContext.class,i);
4556                }
4557                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
4558                public TerminalNode CDATA(int i) {
4559                        return getToken(JavadocParser.CDATA, i);
4560                }
4561                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4562                public TerminalNode NEWLINE(int i) {
4563                        return getToken(JavadocParser.NEWLINE, i);
4564                }
4565                public List<TextContext> text() {
4566                        return getRuleContexts(TextContext.class);
4567                }
4568                public TextContext text(int i) {
4569                        return getRuleContext(TextContext.class,i);
4570                }
4571                public List<JavadocInlineTagContext> javadocInlineTag() {
4572                        return getRuleContexts(JavadocInlineTagContext.class);
4573                }
4574                public JavadocInlineTagContext javadocInlineTag(int i) {
4575                        return getRuleContext(JavadocInlineTagContext.class,i);
4576                }
4577                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4578                public TerminalNode LEADING_ASTERISK(int i) {
4579                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4580                }
4581                public ThContext(ParserRuleContext parent, int invokingState) {
4582                        super(parent, invokingState);
4583                }
4584                @Override public int getRuleIndex() { return RULE_th; }
4585                @Override
4586                public void enterRule(ParseTreeListener listener) {
4587                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this);
4588                }
4589                @Override
4590                public void exitRule(ParseTreeListener listener) {
4591                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this);
4592                }
4593                @Override
4594                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4595                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this);
4596                        else return visitor.visitChildren(this);
4597                }
4598        }
4599
4600        public final ThContext th() throws RecognitionException {
4601                ThContext _localctx = new ThContext(_ctx, getState());
4602                enterRule(_localctx, 40, RULE_th);
4603                try {
4604                        int _alt;
4605                        enterOuterAlt(_localctx, 1);
4606                        {
4607                        setState(606);
4608                        thTagOpen();
4609                        setState(646);
4610                        _errHandler.sync(this);
4611                        _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4612                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4613                                if ( _alt==1 ) {
4614                                        {
4615                                        setState(644);
4616                                        _errHandler.sync(this);
4617                                        switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
4618                                        case 1:
4619                                                {
4620                                                setState(607);
4621                                                htmlTag();
4622                                                }
4623                                                break;
4624                                        case 2:
4625                                                {
4626                                                setState(608);
4627                                                singletonTag();
4628                                                }
4629                                                break;
4630                                        case 3:
4631                                                {
4632                                                setState(609);
4633                                                paragraph();
4634                                                }
4635                                                break;
4636                                        case 4:
4637                                                {
4638                                                setState(610);
4639                                                li();
4640                                                }
4641                                                break;
4642                                        case 5:
4643                                                {
4644                                                setState(611);
4645                                                tr();
4646                                                }
4647                                                break;
4648                                        case 6:
4649                                                {
4650                                                setState(612);
4651                                                td();
4652                                                }
4653                                                break;
4654                                        case 7:
4655                                                {
4656                                                setState(613);
4657                                                body();
4658                                                }
4659                                                break;
4660                                        case 8:
4661                                                {
4662                                                setState(614);
4663                                                colgroup();
4664                                                }
4665                                                break;
4666                                        case 9:
4667                                                {
4668                                                setState(615);
4669                                                dd();
4670                                                }
4671                                                break;
4672                                        case 10:
4673                                                {
4674                                                setState(616);
4675                                                dt();
4676                                                }
4677                                                break;
4678                                        case 11:
4679                                                {
4680                                                setState(617);
4681                                                head();
4682                                                }
4683                                                break;
4684                                        case 12:
4685                                                {
4686                                                setState(618);
4687                                                html();
4688                                                }
4689                                                break;
4690                                        case 13:
4691                                                {
4692                                                setState(619);
4693                                                option();
4694                                                }
4695                                                break;
4696                                        case 14:
4697                                                {
4698                                                setState(620);
4699                                                tbody();
4700                                                }
4701                                                break;
4702                                        case 15:
4703                                                {
4704                                                setState(621);
4705                                                thead();
4706                                                }
4707                                                break;
4708                                        case 16:
4709                                                {
4710                                                setState(622);
4711                                                tfoot();
4712                                                }
4713                                                break;
4714                                        case 17:
4715                                                {
4716                                                setState(623);
4717                                                pTagOpen();
4718                                                }
4719                                                break;
4720                                        case 18:
4721                                                {
4722                                                setState(624);
4723                                                liTagOpen();
4724                                                }
4725                                                break;
4726                                        case 19:
4727                                                {
4728                                                setState(625);
4729                                                trTagOpen();
4730                                                }
4731                                                break;
4732                                        case 20:
4733                                                {
4734                                                setState(626);
4735                                                tdTagOpen();
4736                                                }
4737                                                break;
4738                                        case 21:
4739                                                {
4740                                                setState(627);
4741                                                bodyTagOpen();
4742                                                }
4743                                                break;
4744                                        case 22:
4745                                                {
4746                                                setState(628);
4747                                                colgroupTagOpen();
4748                                                }
4749                                                break;
4750                                        case 23:
4751                                                {
4752                                                setState(629);
4753                                                ddTagOpen();
4754                                                }
4755                                                break;
4756                                        case 24:
4757                                                {
4758                                                setState(630);
4759                                                dtTagOpen();
4760                                                }
4761                                                break;
4762                                        case 25:
4763                                                {
4764                                                setState(631);
4765                                                headTagOpen();
4766                                                }
4767                                                break;
4768                                        case 26:
4769                                                {
4770                                                setState(632);
4771                                                htmlTagOpen();
4772                                                }
4773                                                break;
4774                                        case 27:
4775                                                {
4776                                                setState(633);
4777                                                optionTagOpen();
4778                                                }
4779                                                break;
4780                                        case 28:
4781                                                {
4782                                                setState(634);
4783                                                tbodyTagOpen();
4784                                                }
4785                                                break;
4786                                        case 29:
4787                                                {
4788                                                setState(635);
4789                                                theadTagOpen();
4790                                                }
4791                                                break;
4792                                        case 30:
4793                                                {
4794                                                setState(636);
4795                                                tfootTagOpen();
4796                                                }
4797                                                break;
4798                                        case 31:
4799                                                {
4800                                                {
4801                                                setState(637);
4802                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
4803                                                setState(638);
4804                                                match(LEADING_ASTERISK);
4805                                                }
4806                                                }
4807                                                break;
4808                                        case 32:
4809                                                {
4810                                                setState(639);
4811                                                htmlComment();
4812                                                }
4813                                                break;
4814                                        case 33:
4815                                                {
4816                                                setState(640);
4817                                                match(CDATA);
4818                                                }
4819                                                break;
4820                                        case 34:
4821                                                {
4822                                                setState(641);
4823                                                match(NEWLINE);
4824                                                }
4825                                                break;
4826                                        case 35:
4827                                                {
4828                                                setState(642);
4829                                                text();
4830                                                }
4831                                                break;
4832                                        case 36:
4833                                                {
4834                                                setState(643);
4835                                                javadocInlineTag();
4836                                                }
4837                                                break;
4838                                        }
4839                                        } 
4840                                }
4841                                setState(648);
4842                                _errHandler.sync(this);
4843                                _alt = getInterpreter().adaptivePredict(_input,41,_ctx);
4844                        }
4845                        setState(649);
4846                        thTagClose();
4847                        }
4848                }
4849                catch (RecognitionException re) {
4850                        _localctx.exception = re;
4851                        _errHandler.reportError(this, re);
4852                        _errHandler.recover(this, re);
4853                }
4854                finally {
4855                        exitRule();
4856                }
4857                return _localctx;
4858        }
4859
4860        public static class BodyTagOpenContext extends ParserRuleContext {
4861                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4862                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4863                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4864                public List<AttributeContext> attribute() {
4865                        return getRuleContexts(AttributeContext.class);
4866                }
4867                public AttributeContext attribute(int i) {
4868                        return getRuleContext(AttributeContext.class,i);
4869                }
4870                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4871                public TerminalNode NEWLINE(int i) {
4872                        return getToken(JavadocParser.NEWLINE, i);
4873                }
4874                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4875                public TerminalNode LEADING_ASTERISK(int i) {
4876                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4877                }
4878                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4879                public TerminalNode WS(int i) {
4880                        return getToken(JavadocParser.WS, i);
4881                }
4882                public BodyTagOpenContext(ParserRuleContext parent, int invokingState) {
4883                        super(parent, invokingState);
4884                }
4885                @Override public int getRuleIndex() { return RULE_bodyTagOpen; }
4886                @Override
4887                public void enterRule(ParseTreeListener listener) {
4888                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this);
4889                }
4890                @Override
4891                public void exitRule(ParseTreeListener listener) {
4892                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this);
4893                }
4894                @Override
4895                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4896                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this);
4897                        else return visitor.visitChildren(this);
4898                }
4899        }
4900
4901        public final BodyTagOpenContext bodyTagOpen() throws RecognitionException {
4902                BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState());
4903                enterRule(_localctx, 42, RULE_bodyTagOpen);
4904                int _la;
4905                try {
4906                        enterOuterAlt(_localctx, 1);
4907                        {
4908                        setState(651);
4909                        match(OPEN);
4910                        setState(652);
4911                        match(BODY_HTML_TAG_NAME);
4912                        setState(659);
4913                        _errHandler.sync(this);
4914                        _la = _input.LA(1);
4915                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
4916                                {
4917                                setState(657);
4918                                switch (_input.LA(1)) {
4919                                case HTML_TAG_NAME:
4920                                        {
4921                                        setState(653);
4922                                        attribute();
4923                                        }
4924                                        break;
4925                                case NEWLINE:
4926                                        {
4927                                        setState(654);
4928                                        match(NEWLINE);
4929                                        }
4930                                        break;
4931                                case LEADING_ASTERISK:
4932                                        {
4933                                        setState(655);
4934                                        match(LEADING_ASTERISK);
4935                                        }
4936                                        break;
4937                                case WS:
4938                                        {
4939                                        setState(656);
4940                                        match(WS);
4941                                        }
4942                                        break;
4943                                default:
4944                                        throw new NoViableAltException(this);
4945                                }
4946                                }
4947                                setState(661);
4948                                _errHandler.sync(this);
4949                                _la = _input.LA(1);
4950                        }
4951                        setState(662);
4952                        match(CLOSE);
4953                        }
4954                }
4955                catch (RecognitionException re) {
4956                        _localctx.exception = re;
4957                        _errHandler.reportError(this, re);
4958                        _errHandler.recover(this, re);
4959                }
4960                finally {
4961                        exitRule();
4962                }
4963                return _localctx;
4964        }
4965
4966        public static class BodyTagCloseContext extends ParserRuleContext {
4967                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
4968                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
4969                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
4970                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
4971                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
4972                public TerminalNode NEWLINE(int i) {
4973                        return getToken(JavadocParser.NEWLINE, i);
4974                }
4975                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
4976                public TerminalNode LEADING_ASTERISK(int i) {
4977                        return getToken(JavadocParser.LEADING_ASTERISK, i);
4978                }
4979                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
4980                public TerminalNode WS(int i) {
4981                        return getToken(JavadocParser.WS, i);
4982                }
4983                public BodyTagCloseContext(ParserRuleContext parent, int invokingState) {
4984                        super(parent, invokingState);
4985                }
4986                @Override public int getRuleIndex() { return RULE_bodyTagClose; }
4987                @Override
4988                public void enterRule(ParseTreeListener listener) {
4989                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this);
4990                }
4991                @Override
4992                public void exitRule(ParseTreeListener listener) {
4993                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this);
4994                }
4995                @Override
4996                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
4997                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this);
4998                        else return visitor.visitChildren(this);
4999                }
5000        }
5001
5002        public final BodyTagCloseContext bodyTagClose() throws RecognitionException {
5003                BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState());
5004                enterRule(_localctx, 44, RULE_bodyTagClose);
5005                int _la;
5006                try {
5007                        enterOuterAlt(_localctx, 1);
5008                        {
5009                        setState(664);
5010                        match(OPEN);
5011                        setState(665);
5012                        match(SLASH);
5013                        setState(666);
5014                        match(BODY_HTML_TAG_NAME);
5015                        setState(670);
5016                        _errHandler.sync(this);
5017                        _la = _input.LA(1);
5018                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5019                                {
5020                                {
5021                                setState(667);
5022                                _la = _input.LA(1);
5023                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5024                                _errHandler.recoverInline(this);
5025                                } else {
5026                                        consume();
5027                                }
5028                                }
5029                                }
5030                                setState(672);
5031                                _errHandler.sync(this);
5032                                _la = _input.LA(1);
5033                        }
5034                        setState(673);
5035                        match(CLOSE);
5036                        }
5037                }
5038                catch (RecognitionException re) {
5039                        _localctx.exception = re;
5040                        _errHandler.reportError(this, re);
5041                        _errHandler.recover(this, re);
5042                }
5043                finally {
5044                        exitRule();
5045                }
5046                return _localctx;
5047        }
5048
5049        public static class BodyContext extends ParserRuleContext {
5050                public BodyTagOpenContext bodyTagOpen() {
5051                        return getRuleContext(BodyTagOpenContext.class,0);
5052                }
5053                public BodyTagCloseContext bodyTagClose() {
5054                        return getRuleContext(BodyTagCloseContext.class,0);
5055                }
5056                public List<HtmlTagContext> htmlTag() {
5057                        return getRuleContexts(HtmlTagContext.class);
5058                }
5059                public HtmlTagContext htmlTag(int i) {
5060                        return getRuleContext(HtmlTagContext.class,i);
5061                }
5062                public List<SingletonTagContext> singletonTag() {
5063                        return getRuleContexts(SingletonTagContext.class);
5064                }
5065                public SingletonTagContext singletonTag(int i) {
5066                        return getRuleContext(SingletonTagContext.class,i);
5067                }
5068                public List<ParagraphContext> paragraph() {
5069                        return getRuleContexts(ParagraphContext.class);
5070                }
5071                public ParagraphContext paragraph(int i) {
5072                        return getRuleContext(ParagraphContext.class,i);
5073                }
5074                public List<LiContext> li() {
5075                        return getRuleContexts(LiContext.class);
5076                }
5077                public LiContext li(int i) {
5078                        return getRuleContext(LiContext.class,i);
5079                }
5080                public List<TrContext> tr() {
5081                        return getRuleContexts(TrContext.class);
5082                }
5083                public TrContext tr(int i) {
5084                        return getRuleContext(TrContext.class,i);
5085                }
5086                public List<TdContext> td() {
5087                        return getRuleContexts(TdContext.class);
5088                }
5089                public TdContext td(int i) {
5090                        return getRuleContext(TdContext.class,i);
5091                }
5092                public List<ThContext> th() {
5093                        return getRuleContexts(ThContext.class);
5094                }
5095                public ThContext th(int i) {
5096                        return getRuleContext(ThContext.class,i);
5097                }
5098                public List<ColgroupContext> colgroup() {
5099                        return getRuleContexts(ColgroupContext.class);
5100                }
5101                public ColgroupContext colgroup(int i) {
5102                        return getRuleContext(ColgroupContext.class,i);
5103                }
5104                public List<DdContext> dd() {
5105                        return getRuleContexts(DdContext.class);
5106                }
5107                public DdContext dd(int i) {
5108                        return getRuleContext(DdContext.class,i);
5109                }
5110                public List<DtContext> dt() {
5111                        return getRuleContexts(DtContext.class);
5112                }
5113                public DtContext dt(int i) {
5114                        return getRuleContext(DtContext.class,i);
5115                }
5116                public List<HeadContext> head() {
5117                        return getRuleContexts(HeadContext.class);
5118                }
5119                public HeadContext head(int i) {
5120                        return getRuleContext(HeadContext.class,i);
5121                }
5122                public List<HtmlContext> html() {
5123                        return getRuleContexts(HtmlContext.class);
5124                }
5125                public HtmlContext html(int i) {
5126                        return getRuleContext(HtmlContext.class,i);
5127                }
5128                public List<OptionContext> option() {
5129                        return getRuleContexts(OptionContext.class);
5130                }
5131                public OptionContext option(int i) {
5132                        return getRuleContext(OptionContext.class,i);
5133                }
5134                public List<TbodyContext> tbody() {
5135                        return getRuleContexts(TbodyContext.class);
5136                }
5137                public TbodyContext tbody(int i) {
5138                        return getRuleContext(TbodyContext.class,i);
5139                }
5140                public List<TheadContext> thead() {
5141                        return getRuleContexts(TheadContext.class);
5142                }
5143                public TheadContext thead(int i) {
5144                        return getRuleContext(TheadContext.class,i);
5145                }
5146                public List<TfootContext> tfoot() {
5147                        return getRuleContexts(TfootContext.class);
5148                }
5149                public TfootContext tfoot(int i) {
5150                        return getRuleContext(TfootContext.class,i);
5151                }
5152                public List<PTagOpenContext> pTagOpen() {
5153                        return getRuleContexts(PTagOpenContext.class);
5154                }
5155                public PTagOpenContext pTagOpen(int i) {
5156                        return getRuleContext(PTagOpenContext.class,i);
5157                }
5158                public List<LiTagOpenContext> liTagOpen() {
5159                        return getRuleContexts(LiTagOpenContext.class);
5160                }
5161                public LiTagOpenContext liTagOpen(int i) {
5162                        return getRuleContext(LiTagOpenContext.class,i);
5163                }
5164                public List<TrTagOpenContext> trTagOpen() {
5165                        return getRuleContexts(TrTagOpenContext.class);
5166                }
5167                public TrTagOpenContext trTagOpen(int i) {
5168                        return getRuleContext(TrTagOpenContext.class,i);
5169                }
5170                public List<TdTagOpenContext> tdTagOpen() {
5171                        return getRuleContexts(TdTagOpenContext.class);
5172                }
5173                public TdTagOpenContext tdTagOpen(int i) {
5174                        return getRuleContext(TdTagOpenContext.class,i);
5175                }
5176                public List<ThTagOpenContext> thTagOpen() {
5177                        return getRuleContexts(ThTagOpenContext.class);
5178                }
5179                public ThTagOpenContext thTagOpen(int i) {
5180                        return getRuleContext(ThTagOpenContext.class,i);
5181                }
5182                public List<ColgroupTagOpenContext> colgroupTagOpen() {
5183                        return getRuleContexts(ColgroupTagOpenContext.class);
5184                }
5185                public ColgroupTagOpenContext colgroupTagOpen(int i) {
5186                        return getRuleContext(ColgroupTagOpenContext.class,i);
5187                }
5188                public List<DdTagOpenContext> ddTagOpen() {
5189                        return getRuleContexts(DdTagOpenContext.class);
5190                }
5191                public DdTagOpenContext ddTagOpen(int i) {
5192                        return getRuleContext(DdTagOpenContext.class,i);
5193                }
5194                public List<DtTagOpenContext> dtTagOpen() {
5195                        return getRuleContexts(DtTagOpenContext.class);
5196                }
5197                public DtTagOpenContext dtTagOpen(int i) {
5198                        return getRuleContext(DtTagOpenContext.class,i);
5199                }
5200                public List<HeadTagOpenContext> headTagOpen() {
5201                        return getRuleContexts(HeadTagOpenContext.class);
5202                }
5203                public HeadTagOpenContext headTagOpen(int i) {
5204                        return getRuleContext(HeadTagOpenContext.class,i);
5205                }
5206                public List<HtmlTagOpenContext> htmlTagOpen() {
5207                        return getRuleContexts(HtmlTagOpenContext.class);
5208                }
5209                public HtmlTagOpenContext htmlTagOpen(int i) {
5210                        return getRuleContext(HtmlTagOpenContext.class,i);
5211                }
5212                public List<OptionTagOpenContext> optionTagOpen() {
5213                        return getRuleContexts(OptionTagOpenContext.class);
5214                }
5215                public OptionTagOpenContext optionTagOpen(int i) {
5216                        return getRuleContext(OptionTagOpenContext.class,i);
5217                }
5218                public List<TbodyTagOpenContext> tbodyTagOpen() {
5219                        return getRuleContexts(TbodyTagOpenContext.class);
5220                }
5221                public TbodyTagOpenContext tbodyTagOpen(int i) {
5222                        return getRuleContext(TbodyTagOpenContext.class,i);
5223                }
5224                public List<TheadTagOpenContext> theadTagOpen() {
5225                        return getRuleContexts(TheadTagOpenContext.class);
5226                }
5227                public TheadTagOpenContext theadTagOpen(int i) {
5228                        return getRuleContext(TheadTagOpenContext.class,i);
5229                }
5230                public List<TfootTagOpenContext> tfootTagOpen() {
5231                        return getRuleContexts(TfootTagOpenContext.class);
5232                }
5233                public TfootTagOpenContext tfootTagOpen(int i) {
5234                        return getRuleContext(TfootTagOpenContext.class,i);
5235                }
5236                public List<HtmlCommentContext> htmlComment() {
5237                        return getRuleContexts(HtmlCommentContext.class);
5238                }
5239                public HtmlCommentContext htmlComment(int i) {
5240                        return getRuleContext(HtmlCommentContext.class,i);
5241                }
5242                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5243                public TerminalNode CDATA(int i) {
5244                        return getToken(JavadocParser.CDATA, i);
5245                }
5246                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5247                public TerminalNode NEWLINE(int i) {
5248                        return getToken(JavadocParser.NEWLINE, i);
5249                }
5250                public List<TextContext> text() {
5251                        return getRuleContexts(TextContext.class);
5252                }
5253                public TextContext text(int i) {
5254                        return getRuleContext(TextContext.class,i);
5255                }
5256                public List<JavadocInlineTagContext> javadocInlineTag() {
5257                        return getRuleContexts(JavadocInlineTagContext.class);
5258                }
5259                public JavadocInlineTagContext javadocInlineTag(int i) {
5260                        return getRuleContext(JavadocInlineTagContext.class,i);
5261                }
5262                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5263                public TerminalNode LEADING_ASTERISK(int i) {
5264                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5265                }
5266                public BodyContext(ParserRuleContext parent, int invokingState) {
5267                        super(parent, invokingState);
5268                }
5269                @Override public int getRuleIndex() { return RULE_body; }
5270                @Override
5271                public void enterRule(ParseTreeListener listener) {
5272                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this);
5273                }
5274                @Override
5275                public void exitRule(ParseTreeListener listener) {
5276                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this);
5277                }
5278                @Override
5279                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5280                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this);
5281                        else return visitor.visitChildren(this);
5282                }
5283        }
5284
5285        public final BodyContext body() throws RecognitionException {
5286                BodyContext _localctx = new BodyContext(_ctx, getState());
5287                enterRule(_localctx, 46, RULE_body);
5288                try {
5289                        int _alt;
5290                        enterOuterAlt(_localctx, 1);
5291                        {
5292                        setState(675);
5293                        bodyTagOpen();
5294                        setState(715);
5295                        _errHandler.sync(this);
5296                        _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5297                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5298                                if ( _alt==1 ) {
5299                                        {
5300                                        setState(713);
5301                                        _errHandler.sync(this);
5302                                        switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
5303                                        case 1:
5304                                                {
5305                                                setState(676);
5306                                                htmlTag();
5307                                                }
5308                                                break;
5309                                        case 2:
5310                                                {
5311                                                setState(677);
5312                                                singletonTag();
5313                                                }
5314                                                break;
5315                                        case 3:
5316                                                {
5317                                                setState(678);
5318                                                paragraph();
5319                                                }
5320                                                break;
5321                                        case 4:
5322                                                {
5323                                                setState(679);
5324                                                li();
5325                                                }
5326                                                break;
5327                                        case 5:
5328                                                {
5329                                                setState(680);
5330                                                tr();
5331                                                }
5332                                                break;
5333                                        case 6:
5334                                                {
5335                                                setState(681);
5336                                                td();
5337                                                }
5338                                                break;
5339                                        case 7:
5340                                                {
5341                                                setState(682);
5342                                                th();
5343                                                }
5344                                                break;
5345                                        case 8:
5346                                                {
5347                                                setState(683);
5348                                                colgroup();
5349                                                }
5350                                                break;
5351                                        case 9:
5352                                                {
5353                                                setState(684);
5354                                                dd();
5355                                                }
5356                                                break;
5357                                        case 10:
5358                                                {
5359                                                setState(685);
5360                                                dt();
5361                                                }
5362                                                break;
5363                                        case 11:
5364                                                {
5365                                                setState(686);
5366                                                head();
5367                                                }
5368                                                break;
5369                                        case 12:
5370                                                {
5371                                                setState(687);
5372                                                html();
5373                                                }
5374                                                break;
5375                                        case 13:
5376                                                {
5377                                                setState(688);
5378                                                option();
5379                                                }
5380                                                break;
5381                                        case 14:
5382                                                {
5383                                                setState(689);
5384                                                tbody();
5385                                                }
5386                                                break;
5387                                        case 15:
5388                                                {
5389                                                setState(690);
5390                                                thead();
5391                                                }
5392                                                break;
5393                                        case 16:
5394                                                {
5395                                                setState(691);
5396                                                tfoot();
5397                                                }
5398                                                break;
5399                                        case 17:
5400                                                {
5401                                                setState(692);
5402                                                pTagOpen();
5403                                                }
5404                                                break;
5405                                        case 18:
5406                                                {
5407                                                setState(693);
5408                                                liTagOpen();
5409                                                }
5410                                                break;
5411                                        case 19:
5412                                                {
5413                                                setState(694);
5414                                                trTagOpen();
5415                                                }
5416                                                break;
5417                                        case 20:
5418                                                {
5419                                                setState(695);
5420                                                tdTagOpen();
5421                                                }
5422                                                break;
5423                                        case 21:
5424                                                {
5425                                                setState(696);
5426                                                thTagOpen();
5427                                                }
5428                                                break;
5429                                        case 22:
5430                                                {
5431                                                setState(697);
5432                                                colgroupTagOpen();
5433                                                }
5434                                                break;
5435                                        case 23:
5436                                                {
5437                                                setState(698);
5438                                                ddTagOpen();
5439                                                }
5440                                                break;
5441                                        case 24:
5442                                                {
5443                                                setState(699);
5444                                                dtTagOpen();
5445                                                }
5446                                                break;
5447                                        case 25:
5448                                                {
5449                                                setState(700);
5450                                                headTagOpen();
5451                                                }
5452                                                break;
5453                                        case 26:
5454                                                {
5455                                                setState(701);
5456                                                htmlTagOpen();
5457                                                }
5458                                                break;
5459                                        case 27:
5460                                                {
5461                                                setState(702);
5462                                                optionTagOpen();
5463                                                }
5464                                                break;
5465                                        case 28:
5466                                                {
5467                                                setState(703);
5468                                                tbodyTagOpen();
5469                                                }
5470                                                break;
5471                                        case 29:
5472                                                {
5473                                                setState(704);
5474                                                theadTagOpen();
5475                                                }
5476                                                break;
5477                                        case 30:
5478                                                {
5479                                                setState(705);
5480                                                tfootTagOpen();
5481                                                }
5482                                                break;
5483                                        case 31:
5484                                                {
5485                                                {
5486                                                setState(706);
5487                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
5488                                                setState(707);
5489                                                match(LEADING_ASTERISK);
5490                                                }
5491                                                }
5492                                                break;
5493                                        case 32:
5494                                                {
5495                                                setState(708);
5496                                                htmlComment();
5497                                                }
5498                                                break;
5499                                        case 33:
5500                                                {
5501                                                setState(709);
5502                                                match(CDATA);
5503                                                }
5504                                                break;
5505                                        case 34:
5506                                                {
5507                                                setState(710);
5508                                                match(NEWLINE);
5509                                                }
5510                                                break;
5511                                        case 35:
5512                                                {
5513                                                setState(711);
5514                                                text();
5515                                                }
5516                                                break;
5517                                        case 36:
5518                                                {
5519                                                setState(712);
5520                                                javadocInlineTag();
5521                                                }
5522                                                break;
5523                                        }
5524                                        } 
5525                                }
5526                                setState(717);
5527                                _errHandler.sync(this);
5528                                _alt = getInterpreter().adaptivePredict(_input,46,_ctx);
5529                        }
5530                        setState(718);
5531                        bodyTagClose();
5532                        }
5533                }
5534                catch (RecognitionException re) {
5535                        _localctx.exception = re;
5536                        _errHandler.reportError(this, re);
5537                        _errHandler.recover(this, re);
5538                }
5539                finally {
5540                        exitRule();
5541                }
5542                return _localctx;
5543        }
5544
5545        public static class ColgroupTagOpenContext extends ParserRuleContext {
5546                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5547                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5548                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5549                public List<AttributeContext> attribute() {
5550                        return getRuleContexts(AttributeContext.class);
5551                }
5552                public AttributeContext attribute(int i) {
5553                        return getRuleContext(AttributeContext.class,i);
5554                }
5555                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5556                public TerminalNode NEWLINE(int i) {
5557                        return getToken(JavadocParser.NEWLINE, i);
5558                }
5559                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5560                public TerminalNode LEADING_ASTERISK(int i) {
5561                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5562                }
5563                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5564                public TerminalNode WS(int i) {
5565                        return getToken(JavadocParser.WS, i);
5566                }
5567                public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) {
5568                        super(parent, invokingState);
5569                }
5570                @Override public int getRuleIndex() { return RULE_colgroupTagOpen; }
5571                @Override
5572                public void enterRule(ParseTreeListener listener) {
5573                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this);
5574                }
5575                @Override
5576                public void exitRule(ParseTreeListener listener) {
5577                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this);
5578                }
5579                @Override
5580                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5581                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this);
5582                        else return visitor.visitChildren(this);
5583                }
5584        }
5585
5586        public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException {
5587                ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState());
5588                enterRule(_localctx, 48, RULE_colgroupTagOpen);
5589                int _la;
5590                try {
5591                        enterOuterAlt(_localctx, 1);
5592                        {
5593                        setState(720);
5594                        match(OPEN);
5595                        setState(721);
5596                        match(COLGROUP_HTML_TAG_NAME);
5597                        setState(728);
5598                        _errHandler.sync(this);
5599                        _la = _input.LA(1);
5600                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
5601                                {
5602                                setState(726);
5603                                switch (_input.LA(1)) {
5604                                case HTML_TAG_NAME:
5605                                        {
5606                                        setState(722);
5607                                        attribute();
5608                                        }
5609                                        break;
5610                                case NEWLINE:
5611                                        {
5612                                        setState(723);
5613                                        match(NEWLINE);
5614                                        }
5615                                        break;
5616                                case LEADING_ASTERISK:
5617                                        {
5618                                        setState(724);
5619                                        match(LEADING_ASTERISK);
5620                                        }
5621                                        break;
5622                                case WS:
5623                                        {
5624                                        setState(725);
5625                                        match(WS);
5626                                        }
5627                                        break;
5628                                default:
5629                                        throw new NoViableAltException(this);
5630                                }
5631                                }
5632                                setState(730);
5633                                _errHandler.sync(this);
5634                                _la = _input.LA(1);
5635                        }
5636                        setState(731);
5637                        match(CLOSE);
5638                        }
5639                }
5640                catch (RecognitionException re) {
5641                        _localctx.exception = re;
5642                        _errHandler.reportError(this, re);
5643                        _errHandler.recover(this, re);
5644                }
5645                finally {
5646                        exitRule();
5647                }
5648                return _localctx;
5649        }
5650
5651        public static class ColgroupTagCloseContext extends ParserRuleContext {
5652                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
5653                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
5654                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
5655                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
5656                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5657                public TerminalNode NEWLINE(int i) {
5658                        return getToken(JavadocParser.NEWLINE, i);
5659                }
5660                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5661                public TerminalNode LEADING_ASTERISK(int i) {
5662                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5663                }
5664                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
5665                public TerminalNode WS(int i) {
5666                        return getToken(JavadocParser.WS, i);
5667                }
5668                public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) {
5669                        super(parent, invokingState);
5670                }
5671                @Override public int getRuleIndex() { return RULE_colgroupTagClose; }
5672                @Override
5673                public void enterRule(ParseTreeListener listener) {
5674                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this);
5675                }
5676                @Override
5677                public void exitRule(ParseTreeListener listener) {
5678                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this);
5679                }
5680                @Override
5681                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5682                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this);
5683                        else return visitor.visitChildren(this);
5684                }
5685        }
5686
5687        public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException {
5688                ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState());
5689                enterRule(_localctx, 50, RULE_colgroupTagClose);
5690                int _la;
5691                try {
5692                        enterOuterAlt(_localctx, 1);
5693                        {
5694                        setState(733);
5695                        match(OPEN);
5696                        setState(734);
5697                        match(SLASH);
5698                        setState(735);
5699                        match(COLGROUP_HTML_TAG_NAME);
5700                        setState(739);
5701                        _errHandler.sync(this);
5702                        _la = _input.LA(1);
5703                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
5704                                {
5705                                {
5706                                setState(736);
5707                                _la = _input.LA(1);
5708                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
5709                                _errHandler.recoverInline(this);
5710                                } else {
5711                                        consume();
5712                                }
5713                                }
5714                                }
5715                                setState(741);
5716                                _errHandler.sync(this);
5717                                _la = _input.LA(1);
5718                        }
5719                        setState(742);
5720                        match(CLOSE);
5721                        }
5722                }
5723                catch (RecognitionException re) {
5724                        _localctx.exception = re;
5725                        _errHandler.reportError(this, re);
5726                        _errHandler.recover(this, re);
5727                }
5728                finally {
5729                        exitRule();
5730                }
5731                return _localctx;
5732        }
5733
5734        public static class ColgroupContext extends ParserRuleContext {
5735                public ColgroupTagOpenContext colgroupTagOpen() {
5736                        return getRuleContext(ColgroupTagOpenContext.class,0);
5737                }
5738                public ColgroupTagCloseContext colgroupTagClose() {
5739                        return getRuleContext(ColgroupTagCloseContext.class,0);
5740                }
5741                public List<HtmlTagContext> htmlTag() {
5742                        return getRuleContexts(HtmlTagContext.class);
5743                }
5744                public HtmlTagContext htmlTag(int i) {
5745                        return getRuleContext(HtmlTagContext.class,i);
5746                }
5747                public List<SingletonTagContext> singletonTag() {
5748                        return getRuleContexts(SingletonTagContext.class);
5749                }
5750                public SingletonTagContext singletonTag(int i) {
5751                        return getRuleContext(SingletonTagContext.class,i);
5752                }
5753                public List<ParagraphContext> paragraph() {
5754                        return getRuleContexts(ParagraphContext.class);
5755                }
5756                public ParagraphContext paragraph(int i) {
5757                        return getRuleContext(ParagraphContext.class,i);
5758                }
5759                public List<LiContext> li() {
5760                        return getRuleContexts(LiContext.class);
5761                }
5762                public LiContext li(int i) {
5763                        return getRuleContext(LiContext.class,i);
5764                }
5765                public List<TrContext> tr() {
5766                        return getRuleContexts(TrContext.class);
5767                }
5768                public TrContext tr(int i) {
5769                        return getRuleContext(TrContext.class,i);
5770                }
5771                public List<TdContext> td() {
5772                        return getRuleContexts(TdContext.class);
5773                }
5774                public TdContext td(int i) {
5775                        return getRuleContext(TdContext.class,i);
5776                }
5777                public List<ThContext> th() {
5778                        return getRuleContexts(ThContext.class);
5779                }
5780                public ThContext th(int i) {
5781                        return getRuleContext(ThContext.class,i);
5782                }
5783                public List<BodyContext> body() {
5784                        return getRuleContexts(BodyContext.class);
5785                }
5786                public BodyContext body(int i) {
5787                        return getRuleContext(BodyContext.class,i);
5788                }
5789                public List<DdContext> dd() {
5790                        return getRuleContexts(DdContext.class);
5791                }
5792                public DdContext dd(int i) {
5793                        return getRuleContext(DdContext.class,i);
5794                }
5795                public List<DtContext> dt() {
5796                        return getRuleContexts(DtContext.class);
5797                }
5798                public DtContext dt(int i) {
5799                        return getRuleContext(DtContext.class,i);
5800                }
5801                public List<HeadContext> head() {
5802                        return getRuleContexts(HeadContext.class);
5803                }
5804                public HeadContext head(int i) {
5805                        return getRuleContext(HeadContext.class,i);
5806                }
5807                public List<HtmlContext> html() {
5808                        return getRuleContexts(HtmlContext.class);
5809                }
5810                public HtmlContext html(int i) {
5811                        return getRuleContext(HtmlContext.class,i);
5812                }
5813                public List<OptionContext> option() {
5814                        return getRuleContexts(OptionContext.class);
5815                }
5816                public OptionContext option(int i) {
5817                        return getRuleContext(OptionContext.class,i);
5818                }
5819                public List<TbodyContext> tbody() {
5820                        return getRuleContexts(TbodyContext.class);
5821                }
5822                public TbodyContext tbody(int i) {
5823                        return getRuleContext(TbodyContext.class,i);
5824                }
5825                public List<TheadContext> thead() {
5826                        return getRuleContexts(TheadContext.class);
5827                }
5828                public TheadContext thead(int i) {
5829                        return getRuleContext(TheadContext.class,i);
5830                }
5831                public List<TfootContext> tfoot() {
5832                        return getRuleContexts(TfootContext.class);
5833                }
5834                public TfootContext tfoot(int i) {
5835                        return getRuleContext(TfootContext.class,i);
5836                }
5837                public List<PTagOpenContext> pTagOpen() {
5838                        return getRuleContexts(PTagOpenContext.class);
5839                }
5840                public PTagOpenContext pTagOpen(int i) {
5841                        return getRuleContext(PTagOpenContext.class,i);
5842                }
5843                public List<LiTagOpenContext> liTagOpen() {
5844                        return getRuleContexts(LiTagOpenContext.class);
5845                }
5846                public LiTagOpenContext liTagOpen(int i) {
5847                        return getRuleContext(LiTagOpenContext.class,i);
5848                }
5849                public List<TrTagOpenContext> trTagOpen() {
5850                        return getRuleContexts(TrTagOpenContext.class);
5851                }
5852                public TrTagOpenContext trTagOpen(int i) {
5853                        return getRuleContext(TrTagOpenContext.class,i);
5854                }
5855                public List<TdTagOpenContext> tdTagOpen() {
5856                        return getRuleContexts(TdTagOpenContext.class);
5857                }
5858                public TdTagOpenContext tdTagOpen(int i) {
5859                        return getRuleContext(TdTagOpenContext.class,i);
5860                }
5861                public List<ThTagOpenContext> thTagOpen() {
5862                        return getRuleContexts(ThTagOpenContext.class);
5863                }
5864                public ThTagOpenContext thTagOpen(int i) {
5865                        return getRuleContext(ThTagOpenContext.class,i);
5866                }
5867                public List<BodyTagOpenContext> bodyTagOpen() {
5868                        return getRuleContexts(BodyTagOpenContext.class);
5869                }
5870                public BodyTagOpenContext bodyTagOpen(int i) {
5871                        return getRuleContext(BodyTagOpenContext.class,i);
5872                }
5873                public List<DdTagOpenContext> ddTagOpen() {
5874                        return getRuleContexts(DdTagOpenContext.class);
5875                }
5876                public DdTagOpenContext ddTagOpen(int i) {
5877                        return getRuleContext(DdTagOpenContext.class,i);
5878                }
5879                public List<DtTagOpenContext> dtTagOpen() {
5880                        return getRuleContexts(DtTagOpenContext.class);
5881                }
5882                public DtTagOpenContext dtTagOpen(int i) {
5883                        return getRuleContext(DtTagOpenContext.class,i);
5884                }
5885                public List<HeadTagOpenContext> headTagOpen() {
5886                        return getRuleContexts(HeadTagOpenContext.class);
5887                }
5888                public HeadTagOpenContext headTagOpen(int i) {
5889                        return getRuleContext(HeadTagOpenContext.class,i);
5890                }
5891                public List<HtmlTagOpenContext> htmlTagOpen() {
5892                        return getRuleContexts(HtmlTagOpenContext.class);
5893                }
5894                public HtmlTagOpenContext htmlTagOpen(int i) {
5895                        return getRuleContext(HtmlTagOpenContext.class,i);
5896                }
5897                public List<OptionTagOpenContext> optionTagOpen() {
5898                        return getRuleContexts(OptionTagOpenContext.class);
5899                }
5900                public OptionTagOpenContext optionTagOpen(int i) {
5901                        return getRuleContext(OptionTagOpenContext.class,i);
5902                }
5903                public List<TbodyTagOpenContext> tbodyTagOpen() {
5904                        return getRuleContexts(TbodyTagOpenContext.class);
5905                }
5906                public TbodyTagOpenContext tbodyTagOpen(int i) {
5907                        return getRuleContext(TbodyTagOpenContext.class,i);
5908                }
5909                public List<TheadTagOpenContext> theadTagOpen() {
5910                        return getRuleContexts(TheadTagOpenContext.class);
5911                }
5912                public TheadTagOpenContext theadTagOpen(int i) {
5913                        return getRuleContext(TheadTagOpenContext.class,i);
5914                }
5915                public List<TfootTagOpenContext> tfootTagOpen() {
5916                        return getRuleContexts(TfootTagOpenContext.class);
5917                }
5918                public TfootTagOpenContext tfootTagOpen(int i) {
5919                        return getRuleContext(TfootTagOpenContext.class,i);
5920                }
5921                public List<HtmlCommentContext> htmlComment() {
5922                        return getRuleContexts(HtmlCommentContext.class);
5923                }
5924                public HtmlCommentContext htmlComment(int i) {
5925                        return getRuleContext(HtmlCommentContext.class,i);
5926                }
5927                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
5928                public TerminalNode CDATA(int i) {
5929                        return getToken(JavadocParser.CDATA, i);
5930                }
5931                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
5932                public TerminalNode NEWLINE(int i) {
5933                        return getToken(JavadocParser.NEWLINE, i);
5934                }
5935                public List<TextContext> text() {
5936                        return getRuleContexts(TextContext.class);
5937                }
5938                public TextContext text(int i) {
5939                        return getRuleContext(TextContext.class,i);
5940                }
5941                public List<JavadocInlineTagContext> javadocInlineTag() {
5942                        return getRuleContexts(JavadocInlineTagContext.class);
5943                }
5944                public JavadocInlineTagContext javadocInlineTag(int i) {
5945                        return getRuleContext(JavadocInlineTagContext.class,i);
5946                }
5947                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
5948                public TerminalNode LEADING_ASTERISK(int i) {
5949                        return getToken(JavadocParser.LEADING_ASTERISK, i);
5950                }
5951                public ColgroupContext(ParserRuleContext parent, int invokingState) {
5952                        super(parent, invokingState);
5953                }
5954                @Override public int getRuleIndex() { return RULE_colgroup; }
5955                @Override
5956                public void enterRule(ParseTreeListener listener) {
5957                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this);
5958                }
5959                @Override
5960                public void exitRule(ParseTreeListener listener) {
5961                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this);
5962                }
5963                @Override
5964                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
5965                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this);
5966                        else return visitor.visitChildren(this);
5967                }
5968        }
5969
5970        public final ColgroupContext colgroup() throws RecognitionException {
5971                ColgroupContext _localctx = new ColgroupContext(_ctx, getState());
5972                enterRule(_localctx, 52, RULE_colgroup);
5973                try {
5974                        int _alt;
5975                        enterOuterAlt(_localctx, 1);
5976                        {
5977                        setState(744);
5978                        colgroupTagOpen();
5979                        setState(784);
5980                        _errHandler.sync(this);
5981                        _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
5982                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5983                                if ( _alt==1 ) {
5984                                        {
5985                                        setState(782);
5986                                        _errHandler.sync(this);
5987                                        switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
5988                                        case 1:
5989                                                {
5990                                                setState(745);
5991                                                htmlTag();
5992                                                }
5993                                                break;
5994                                        case 2:
5995                                                {
5996                                                setState(746);
5997                                                singletonTag();
5998                                                }
5999                                                break;
6000                                        case 3:
6001                                                {
6002                                                setState(747);
6003                                                paragraph();
6004                                                }
6005                                                break;
6006                                        case 4:
6007                                                {
6008                                                setState(748);
6009                                                li();
6010                                                }
6011                                                break;
6012                                        case 5:
6013                                                {
6014                                                setState(749);
6015                                                tr();
6016                                                }
6017                                                break;
6018                                        case 6:
6019                                                {
6020                                                setState(750);
6021                                                td();
6022                                                }
6023                                                break;
6024                                        case 7:
6025                                                {
6026                                                setState(751);
6027                                                th();
6028                                                }
6029                                                break;
6030                                        case 8:
6031                                                {
6032                                                setState(752);
6033                                                body();
6034                                                }
6035                                                break;
6036                                        case 9:
6037                                                {
6038                                                setState(753);
6039                                                dd();
6040                                                }
6041                                                break;
6042                                        case 10:
6043                                                {
6044                                                setState(754);
6045                                                dt();
6046                                                }
6047                                                break;
6048                                        case 11:
6049                                                {
6050                                                setState(755);
6051                                                head();
6052                                                }
6053                                                break;
6054                                        case 12:
6055                                                {
6056                                                setState(756);
6057                                                html();
6058                                                }
6059                                                break;
6060                                        case 13:
6061                                                {
6062                                                setState(757);
6063                                                option();
6064                                                }
6065                                                break;
6066                                        case 14:
6067                                                {
6068                                                setState(758);
6069                                                tbody();
6070                                                }
6071                                                break;
6072                                        case 15:
6073                                                {
6074                                                setState(759);
6075                                                thead();
6076                                                }
6077                                                break;
6078                                        case 16:
6079                                                {
6080                                                setState(760);
6081                                                tfoot();
6082                                                }
6083                                                break;
6084                                        case 17:
6085                                                {
6086                                                setState(761);
6087                                                pTagOpen();
6088                                                }
6089                                                break;
6090                                        case 18:
6091                                                {
6092                                                setState(762);
6093                                                liTagOpen();
6094                                                }
6095                                                break;
6096                                        case 19:
6097                                                {
6098                                                setState(763);
6099                                                trTagOpen();
6100                                                }
6101                                                break;
6102                                        case 20:
6103                                                {
6104                                                setState(764);
6105                                                tdTagOpen();
6106                                                }
6107                                                break;
6108                                        case 21:
6109                                                {
6110                                                setState(765);
6111                                                thTagOpen();
6112                                                }
6113                                                break;
6114                                        case 22:
6115                                                {
6116                                                setState(766);
6117                                                bodyTagOpen();
6118                                                }
6119                                                break;
6120                                        case 23:
6121                                                {
6122                                                setState(767);
6123                                                ddTagOpen();
6124                                                }
6125                                                break;
6126                                        case 24:
6127                                                {
6128                                                setState(768);
6129                                                dtTagOpen();
6130                                                }
6131                                                break;
6132                                        case 25:
6133                                                {
6134                                                setState(769);
6135                                                headTagOpen();
6136                                                }
6137                                                break;
6138                                        case 26:
6139                                                {
6140                                                setState(770);
6141                                                htmlTagOpen();
6142                                                }
6143                                                break;
6144                                        case 27:
6145                                                {
6146                                                setState(771);
6147                                                optionTagOpen();
6148                                                }
6149                                                break;
6150                                        case 28:
6151                                                {
6152                                                setState(772);
6153                                                tbodyTagOpen();
6154                                                }
6155                                                break;
6156                                        case 29:
6157                                                {
6158                                                setState(773);
6159                                                theadTagOpen();
6160                                                }
6161                                                break;
6162                                        case 30:
6163                                                {
6164                                                setState(774);
6165                                                tfootTagOpen();
6166                                                }
6167                                                break;
6168                                        case 31:
6169                                                {
6170                                                {
6171                                                setState(775);
6172                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6173                                                setState(776);
6174                                                match(LEADING_ASTERISK);
6175                                                }
6176                                                }
6177                                                break;
6178                                        case 32:
6179                                                {
6180                                                setState(777);
6181                                                htmlComment();
6182                                                }
6183                                                break;
6184                                        case 33:
6185                                                {
6186                                                setState(778);
6187                                                match(CDATA);
6188                                                }
6189                                                break;
6190                                        case 34:
6191                                                {
6192                                                setState(779);
6193                                                match(NEWLINE);
6194                                                }
6195                                                break;
6196                                        case 35:
6197                                                {
6198                                                setState(780);
6199                                                text();
6200                                                }
6201                                                break;
6202                                        case 36:
6203                                                {
6204                                                setState(781);
6205                                                javadocInlineTag();
6206                                                }
6207                                                break;
6208                                        }
6209                                        } 
6210                                }
6211                                setState(786);
6212                                _errHandler.sync(this);
6213                                _alt = getInterpreter().adaptivePredict(_input,51,_ctx);
6214                        }
6215                        setState(787);
6216                        colgroupTagClose();
6217                        }
6218                }
6219                catch (RecognitionException re) {
6220                        _localctx.exception = re;
6221                        _errHandler.reportError(this, re);
6222                        _errHandler.recover(this, re);
6223                }
6224                finally {
6225                        exitRule();
6226                }
6227                return _localctx;
6228        }
6229
6230        public static class DdTagOpenContext extends ParserRuleContext {
6231                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6232                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6233                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6234                public List<AttributeContext> attribute() {
6235                        return getRuleContexts(AttributeContext.class);
6236                }
6237                public AttributeContext attribute(int i) {
6238                        return getRuleContext(AttributeContext.class,i);
6239                }
6240                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6241                public TerminalNode NEWLINE(int i) {
6242                        return getToken(JavadocParser.NEWLINE, i);
6243                }
6244                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6245                public TerminalNode LEADING_ASTERISK(int i) {
6246                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6247                }
6248                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6249                public TerminalNode WS(int i) {
6250                        return getToken(JavadocParser.WS, i);
6251                }
6252                public DdTagOpenContext(ParserRuleContext parent, int invokingState) {
6253                        super(parent, invokingState);
6254                }
6255                @Override public int getRuleIndex() { return RULE_ddTagOpen; }
6256                @Override
6257                public void enterRule(ParseTreeListener listener) {
6258                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this);
6259                }
6260                @Override
6261                public void exitRule(ParseTreeListener listener) {
6262                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this);
6263                }
6264                @Override
6265                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6266                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this);
6267                        else return visitor.visitChildren(this);
6268                }
6269        }
6270
6271        public final DdTagOpenContext ddTagOpen() throws RecognitionException {
6272                DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState());
6273                enterRule(_localctx, 54, RULE_ddTagOpen);
6274                int _la;
6275                try {
6276                        enterOuterAlt(_localctx, 1);
6277                        {
6278                        setState(789);
6279                        match(OPEN);
6280                        setState(790);
6281                        match(DD_HTML_TAG_NAME);
6282                        setState(797);
6283                        _errHandler.sync(this);
6284                        _la = _input.LA(1);
6285                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6286                                {
6287                                setState(795);
6288                                switch (_input.LA(1)) {
6289                                case HTML_TAG_NAME:
6290                                        {
6291                                        setState(791);
6292                                        attribute();
6293                                        }
6294                                        break;
6295                                case NEWLINE:
6296                                        {
6297                                        setState(792);
6298                                        match(NEWLINE);
6299                                        }
6300                                        break;
6301                                case LEADING_ASTERISK:
6302                                        {
6303                                        setState(793);
6304                                        match(LEADING_ASTERISK);
6305                                        }
6306                                        break;
6307                                case WS:
6308                                        {
6309                                        setState(794);
6310                                        match(WS);
6311                                        }
6312                                        break;
6313                                default:
6314                                        throw new NoViableAltException(this);
6315                                }
6316                                }
6317                                setState(799);
6318                                _errHandler.sync(this);
6319                                _la = _input.LA(1);
6320                        }
6321                        setState(800);
6322                        match(CLOSE);
6323                        }
6324                }
6325                catch (RecognitionException re) {
6326                        _localctx.exception = re;
6327                        _errHandler.reportError(this, re);
6328                        _errHandler.recover(this, re);
6329                }
6330                finally {
6331                        exitRule();
6332                }
6333                return _localctx;
6334        }
6335
6336        public static class DdTagCloseContext extends ParserRuleContext {
6337                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6338                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
6339                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
6340                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6341                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6342                public TerminalNode NEWLINE(int i) {
6343                        return getToken(JavadocParser.NEWLINE, i);
6344                }
6345                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6346                public TerminalNode LEADING_ASTERISK(int i) {
6347                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6348                }
6349                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6350                public TerminalNode WS(int i) {
6351                        return getToken(JavadocParser.WS, i);
6352                }
6353                public DdTagCloseContext(ParserRuleContext parent, int invokingState) {
6354                        super(parent, invokingState);
6355                }
6356                @Override public int getRuleIndex() { return RULE_ddTagClose; }
6357                @Override
6358                public void enterRule(ParseTreeListener listener) {
6359                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this);
6360                }
6361                @Override
6362                public void exitRule(ParseTreeListener listener) {
6363                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this);
6364                }
6365                @Override
6366                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6367                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this);
6368                        else return visitor.visitChildren(this);
6369                }
6370        }
6371
6372        public final DdTagCloseContext ddTagClose() throws RecognitionException {
6373                DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState());
6374                enterRule(_localctx, 56, RULE_ddTagClose);
6375                int _la;
6376                try {
6377                        enterOuterAlt(_localctx, 1);
6378                        {
6379                        setState(802);
6380                        match(OPEN);
6381                        setState(803);
6382                        match(SLASH);
6383                        setState(804);
6384                        match(DD_HTML_TAG_NAME);
6385                        setState(808);
6386                        _errHandler.sync(this);
6387                        _la = _input.LA(1);
6388                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
6389                                {
6390                                {
6391                                setState(805);
6392                                _la = _input.LA(1);
6393                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
6394                                _errHandler.recoverInline(this);
6395                                } else {
6396                                        consume();
6397                                }
6398                                }
6399                                }
6400                                setState(810);
6401                                _errHandler.sync(this);
6402                                _la = _input.LA(1);
6403                        }
6404                        setState(811);
6405                        match(CLOSE);
6406                        }
6407                }
6408                catch (RecognitionException re) {
6409                        _localctx.exception = re;
6410                        _errHandler.reportError(this, re);
6411                        _errHandler.recover(this, re);
6412                }
6413                finally {
6414                        exitRule();
6415                }
6416                return _localctx;
6417        }
6418
6419        public static class DdContext extends ParserRuleContext {
6420                public DdTagOpenContext ddTagOpen() {
6421                        return getRuleContext(DdTagOpenContext.class,0);
6422                }
6423                public DdTagCloseContext ddTagClose() {
6424                        return getRuleContext(DdTagCloseContext.class,0);
6425                }
6426                public List<HtmlTagContext> htmlTag() {
6427                        return getRuleContexts(HtmlTagContext.class);
6428                }
6429                public HtmlTagContext htmlTag(int i) {
6430                        return getRuleContext(HtmlTagContext.class,i);
6431                }
6432                public List<SingletonTagContext> singletonTag() {
6433                        return getRuleContexts(SingletonTagContext.class);
6434                }
6435                public SingletonTagContext singletonTag(int i) {
6436                        return getRuleContext(SingletonTagContext.class,i);
6437                }
6438                public List<ParagraphContext> paragraph() {
6439                        return getRuleContexts(ParagraphContext.class);
6440                }
6441                public ParagraphContext paragraph(int i) {
6442                        return getRuleContext(ParagraphContext.class,i);
6443                }
6444                public List<LiContext> li() {
6445                        return getRuleContexts(LiContext.class);
6446                }
6447                public LiContext li(int i) {
6448                        return getRuleContext(LiContext.class,i);
6449                }
6450                public List<TrContext> tr() {
6451                        return getRuleContexts(TrContext.class);
6452                }
6453                public TrContext tr(int i) {
6454                        return getRuleContext(TrContext.class,i);
6455                }
6456                public List<TdContext> td() {
6457                        return getRuleContexts(TdContext.class);
6458                }
6459                public TdContext td(int i) {
6460                        return getRuleContext(TdContext.class,i);
6461                }
6462                public List<ThContext> th() {
6463                        return getRuleContexts(ThContext.class);
6464                }
6465                public ThContext th(int i) {
6466                        return getRuleContext(ThContext.class,i);
6467                }
6468                public List<BodyContext> body() {
6469                        return getRuleContexts(BodyContext.class);
6470                }
6471                public BodyContext body(int i) {
6472                        return getRuleContext(BodyContext.class,i);
6473                }
6474                public List<ColgroupContext> colgroup() {
6475                        return getRuleContexts(ColgroupContext.class);
6476                }
6477                public ColgroupContext colgroup(int i) {
6478                        return getRuleContext(ColgroupContext.class,i);
6479                }
6480                public List<DtContext> dt() {
6481                        return getRuleContexts(DtContext.class);
6482                }
6483                public DtContext dt(int i) {
6484                        return getRuleContext(DtContext.class,i);
6485                }
6486                public List<HeadContext> head() {
6487                        return getRuleContexts(HeadContext.class);
6488                }
6489                public HeadContext head(int i) {
6490                        return getRuleContext(HeadContext.class,i);
6491                }
6492                public List<HtmlContext> html() {
6493                        return getRuleContexts(HtmlContext.class);
6494                }
6495                public HtmlContext html(int i) {
6496                        return getRuleContext(HtmlContext.class,i);
6497                }
6498                public List<OptionContext> option() {
6499                        return getRuleContexts(OptionContext.class);
6500                }
6501                public OptionContext option(int i) {
6502                        return getRuleContext(OptionContext.class,i);
6503                }
6504                public List<TbodyContext> tbody() {
6505                        return getRuleContexts(TbodyContext.class);
6506                }
6507                public TbodyContext tbody(int i) {
6508                        return getRuleContext(TbodyContext.class,i);
6509                }
6510                public List<TheadContext> thead() {
6511                        return getRuleContexts(TheadContext.class);
6512                }
6513                public TheadContext thead(int i) {
6514                        return getRuleContext(TheadContext.class,i);
6515                }
6516                public List<TfootContext> tfoot() {
6517                        return getRuleContexts(TfootContext.class);
6518                }
6519                public TfootContext tfoot(int i) {
6520                        return getRuleContext(TfootContext.class,i);
6521                }
6522                public List<PTagOpenContext> pTagOpen() {
6523                        return getRuleContexts(PTagOpenContext.class);
6524                }
6525                public PTagOpenContext pTagOpen(int i) {
6526                        return getRuleContext(PTagOpenContext.class,i);
6527                }
6528                public List<LiTagOpenContext> liTagOpen() {
6529                        return getRuleContexts(LiTagOpenContext.class);
6530                }
6531                public LiTagOpenContext liTagOpen(int i) {
6532                        return getRuleContext(LiTagOpenContext.class,i);
6533                }
6534                public List<TrTagOpenContext> trTagOpen() {
6535                        return getRuleContexts(TrTagOpenContext.class);
6536                }
6537                public TrTagOpenContext trTagOpen(int i) {
6538                        return getRuleContext(TrTagOpenContext.class,i);
6539                }
6540                public List<TdTagOpenContext> tdTagOpen() {
6541                        return getRuleContexts(TdTagOpenContext.class);
6542                }
6543                public TdTagOpenContext tdTagOpen(int i) {
6544                        return getRuleContext(TdTagOpenContext.class,i);
6545                }
6546                public List<ThTagOpenContext> thTagOpen() {
6547                        return getRuleContexts(ThTagOpenContext.class);
6548                }
6549                public ThTagOpenContext thTagOpen(int i) {
6550                        return getRuleContext(ThTagOpenContext.class,i);
6551                }
6552                public List<BodyTagOpenContext> bodyTagOpen() {
6553                        return getRuleContexts(BodyTagOpenContext.class);
6554                }
6555                public BodyTagOpenContext bodyTagOpen(int i) {
6556                        return getRuleContext(BodyTagOpenContext.class,i);
6557                }
6558                public List<ColgroupTagOpenContext> colgroupTagOpen() {
6559                        return getRuleContexts(ColgroupTagOpenContext.class);
6560                }
6561                public ColgroupTagOpenContext colgroupTagOpen(int i) {
6562                        return getRuleContext(ColgroupTagOpenContext.class,i);
6563                }
6564                public List<DtTagOpenContext> dtTagOpen() {
6565                        return getRuleContexts(DtTagOpenContext.class);
6566                }
6567                public DtTagOpenContext dtTagOpen(int i) {
6568                        return getRuleContext(DtTagOpenContext.class,i);
6569                }
6570                public List<HeadTagOpenContext> headTagOpen() {
6571                        return getRuleContexts(HeadTagOpenContext.class);
6572                }
6573                public HeadTagOpenContext headTagOpen(int i) {
6574                        return getRuleContext(HeadTagOpenContext.class,i);
6575                }
6576                public List<HtmlTagOpenContext> htmlTagOpen() {
6577                        return getRuleContexts(HtmlTagOpenContext.class);
6578                }
6579                public HtmlTagOpenContext htmlTagOpen(int i) {
6580                        return getRuleContext(HtmlTagOpenContext.class,i);
6581                }
6582                public List<OptionTagOpenContext> optionTagOpen() {
6583                        return getRuleContexts(OptionTagOpenContext.class);
6584                }
6585                public OptionTagOpenContext optionTagOpen(int i) {
6586                        return getRuleContext(OptionTagOpenContext.class,i);
6587                }
6588                public List<TbodyTagOpenContext> tbodyTagOpen() {
6589                        return getRuleContexts(TbodyTagOpenContext.class);
6590                }
6591                public TbodyTagOpenContext tbodyTagOpen(int i) {
6592                        return getRuleContext(TbodyTagOpenContext.class,i);
6593                }
6594                public List<TheadTagOpenContext> theadTagOpen() {
6595                        return getRuleContexts(TheadTagOpenContext.class);
6596                }
6597                public TheadTagOpenContext theadTagOpen(int i) {
6598                        return getRuleContext(TheadTagOpenContext.class,i);
6599                }
6600                public List<TfootTagOpenContext> tfootTagOpen() {
6601                        return getRuleContexts(TfootTagOpenContext.class);
6602                }
6603                public TfootTagOpenContext tfootTagOpen(int i) {
6604                        return getRuleContext(TfootTagOpenContext.class,i);
6605                }
6606                public List<HtmlCommentContext> htmlComment() {
6607                        return getRuleContexts(HtmlCommentContext.class);
6608                }
6609                public HtmlCommentContext htmlComment(int i) {
6610                        return getRuleContext(HtmlCommentContext.class,i);
6611                }
6612                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
6613                public TerminalNode CDATA(int i) {
6614                        return getToken(JavadocParser.CDATA, i);
6615                }
6616                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6617                public TerminalNode NEWLINE(int i) {
6618                        return getToken(JavadocParser.NEWLINE, i);
6619                }
6620                public List<TextContext> text() {
6621                        return getRuleContexts(TextContext.class);
6622                }
6623                public TextContext text(int i) {
6624                        return getRuleContext(TextContext.class,i);
6625                }
6626                public List<JavadocInlineTagContext> javadocInlineTag() {
6627                        return getRuleContexts(JavadocInlineTagContext.class);
6628                }
6629                public JavadocInlineTagContext javadocInlineTag(int i) {
6630                        return getRuleContext(JavadocInlineTagContext.class,i);
6631                }
6632                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6633                public TerminalNode LEADING_ASTERISK(int i) {
6634                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6635                }
6636                public DdContext(ParserRuleContext parent, int invokingState) {
6637                        super(parent, invokingState);
6638                }
6639                @Override public int getRuleIndex() { return RULE_dd; }
6640                @Override
6641                public void enterRule(ParseTreeListener listener) {
6642                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this);
6643                }
6644                @Override
6645                public void exitRule(ParseTreeListener listener) {
6646                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this);
6647                }
6648                @Override
6649                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6650                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this);
6651                        else return visitor.visitChildren(this);
6652                }
6653        }
6654
6655        public final DdContext dd() throws RecognitionException {
6656                DdContext _localctx = new DdContext(_ctx, getState());
6657                enterRule(_localctx, 58, RULE_dd);
6658                try {
6659                        int _alt;
6660                        enterOuterAlt(_localctx, 1);
6661                        {
6662                        setState(813);
6663                        ddTagOpen();
6664                        setState(853);
6665                        _errHandler.sync(this);
6666                        _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6667                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
6668                                if ( _alt==1 ) {
6669                                        {
6670                                        setState(851);
6671                                        _errHandler.sync(this);
6672                                        switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
6673                                        case 1:
6674                                                {
6675                                                setState(814);
6676                                                htmlTag();
6677                                                }
6678                                                break;
6679                                        case 2:
6680                                                {
6681                                                setState(815);
6682                                                singletonTag();
6683                                                }
6684                                                break;
6685                                        case 3:
6686                                                {
6687                                                setState(816);
6688                                                paragraph();
6689                                                }
6690                                                break;
6691                                        case 4:
6692                                                {
6693                                                setState(817);
6694                                                li();
6695                                                }
6696                                                break;
6697                                        case 5:
6698                                                {
6699                                                setState(818);
6700                                                tr();
6701                                                }
6702                                                break;
6703                                        case 6:
6704                                                {
6705                                                setState(819);
6706                                                td();
6707                                                }
6708                                                break;
6709                                        case 7:
6710                                                {
6711                                                setState(820);
6712                                                th();
6713                                                }
6714                                                break;
6715                                        case 8:
6716                                                {
6717                                                setState(821);
6718                                                body();
6719                                                }
6720                                                break;
6721                                        case 9:
6722                                                {
6723                                                setState(822);
6724                                                colgroup();
6725                                                }
6726                                                break;
6727                                        case 10:
6728                                                {
6729                                                setState(823);
6730                                                dt();
6731                                                }
6732                                                break;
6733                                        case 11:
6734                                                {
6735                                                setState(824);
6736                                                head();
6737                                                }
6738                                                break;
6739                                        case 12:
6740                                                {
6741                                                setState(825);
6742                                                html();
6743                                                }
6744                                                break;
6745                                        case 13:
6746                                                {
6747                                                setState(826);
6748                                                option();
6749                                                }
6750                                                break;
6751                                        case 14:
6752                                                {
6753                                                setState(827);
6754                                                tbody();
6755                                                }
6756                                                break;
6757                                        case 15:
6758                                                {
6759                                                setState(828);
6760                                                thead();
6761                                                }
6762                                                break;
6763                                        case 16:
6764                                                {
6765                                                setState(829);
6766                                                tfoot();
6767                                                }
6768                                                break;
6769                                        case 17:
6770                                                {
6771                                                setState(830);
6772                                                pTagOpen();
6773                                                }
6774                                                break;
6775                                        case 18:
6776                                                {
6777                                                setState(831);
6778                                                liTagOpen();
6779                                                }
6780                                                break;
6781                                        case 19:
6782                                                {
6783                                                setState(832);
6784                                                trTagOpen();
6785                                                }
6786                                                break;
6787                                        case 20:
6788                                                {
6789                                                setState(833);
6790                                                tdTagOpen();
6791                                                }
6792                                                break;
6793                                        case 21:
6794                                                {
6795                                                setState(834);
6796                                                thTagOpen();
6797                                                }
6798                                                break;
6799                                        case 22:
6800                                                {
6801                                                setState(835);
6802                                                bodyTagOpen();
6803                                                }
6804                                                break;
6805                                        case 23:
6806                                                {
6807                                                setState(836);
6808                                                colgroupTagOpen();
6809                                                }
6810                                                break;
6811                                        case 24:
6812                                                {
6813                                                setState(837);
6814                                                dtTagOpen();
6815                                                }
6816                                                break;
6817                                        case 25:
6818                                                {
6819                                                setState(838);
6820                                                headTagOpen();
6821                                                }
6822                                                break;
6823                                        case 26:
6824                                                {
6825                                                setState(839);
6826                                                htmlTagOpen();
6827                                                }
6828                                                break;
6829                                        case 27:
6830                                                {
6831                                                setState(840);
6832                                                optionTagOpen();
6833                                                }
6834                                                break;
6835                                        case 28:
6836                                                {
6837                                                setState(841);
6838                                                tbodyTagOpen();
6839                                                }
6840                                                break;
6841                                        case 29:
6842                                                {
6843                                                setState(842);
6844                                                theadTagOpen();
6845                                                }
6846                                                break;
6847                                        case 30:
6848                                                {
6849                                                setState(843);
6850                                                tfootTagOpen();
6851                                                }
6852                                                break;
6853                                        case 31:
6854                                                {
6855                                                {
6856                                                setState(844);
6857                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
6858                                                setState(845);
6859                                                match(LEADING_ASTERISK);
6860                                                }
6861                                                }
6862                                                break;
6863                                        case 32:
6864                                                {
6865                                                setState(846);
6866                                                htmlComment();
6867                                                }
6868                                                break;
6869                                        case 33:
6870                                                {
6871                                                setState(847);
6872                                                match(CDATA);
6873                                                }
6874                                                break;
6875                                        case 34:
6876                                                {
6877                                                setState(848);
6878                                                match(NEWLINE);
6879                                                }
6880                                                break;
6881                                        case 35:
6882                                                {
6883                                                setState(849);
6884                                                text();
6885                                                }
6886                                                break;
6887                                        case 36:
6888                                                {
6889                                                setState(850);
6890                                                javadocInlineTag();
6891                                                }
6892                                                break;
6893                                        }
6894                                        } 
6895                                }
6896                                setState(855);
6897                                _errHandler.sync(this);
6898                                _alt = getInterpreter().adaptivePredict(_input,56,_ctx);
6899                        }
6900                        setState(856);
6901                        ddTagClose();
6902                        }
6903                }
6904                catch (RecognitionException re) {
6905                        _localctx.exception = re;
6906                        _errHandler.reportError(this, re);
6907                        _errHandler.recover(this, re);
6908                }
6909                finally {
6910                        exitRule();
6911                }
6912                return _localctx;
6913        }
6914
6915        public static class DtTagOpenContext extends ParserRuleContext {
6916                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
6917                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
6918                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
6919                public List<AttributeContext> attribute() {
6920                        return getRuleContexts(AttributeContext.class);
6921                }
6922                public AttributeContext attribute(int i) {
6923                        return getRuleContext(AttributeContext.class,i);
6924                }
6925                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
6926                public TerminalNode NEWLINE(int i) {
6927                        return getToken(JavadocParser.NEWLINE, i);
6928                }
6929                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
6930                public TerminalNode LEADING_ASTERISK(int i) {
6931                        return getToken(JavadocParser.LEADING_ASTERISK, i);
6932                }
6933                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
6934                public TerminalNode WS(int i) {
6935                        return getToken(JavadocParser.WS, i);
6936                }
6937                public DtTagOpenContext(ParserRuleContext parent, int invokingState) {
6938                        super(parent, invokingState);
6939                }
6940                @Override public int getRuleIndex() { return RULE_dtTagOpen; }
6941                @Override
6942                public void enterRule(ParseTreeListener listener) {
6943                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this);
6944                }
6945                @Override
6946                public void exitRule(ParseTreeListener listener) {
6947                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this);
6948                }
6949                @Override
6950                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
6951                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this);
6952                        else return visitor.visitChildren(this);
6953                }
6954        }
6955
6956        public final DtTagOpenContext dtTagOpen() throws RecognitionException {
6957                DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState());
6958                enterRule(_localctx, 60, RULE_dtTagOpen);
6959                int _la;
6960                try {
6961                        enterOuterAlt(_localctx, 1);
6962                        {
6963                        setState(858);
6964                        match(OPEN);
6965                        setState(859);
6966                        match(DT_HTML_TAG_NAME);
6967                        setState(866);
6968                        _errHandler.sync(this);
6969                        _la = _input.LA(1);
6970                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
6971                                {
6972                                setState(864);
6973                                switch (_input.LA(1)) {
6974                                case HTML_TAG_NAME:
6975                                        {
6976                                        setState(860);
6977                                        attribute();
6978                                        }
6979                                        break;
6980                                case NEWLINE:
6981                                        {
6982                                        setState(861);
6983                                        match(NEWLINE);
6984                                        }
6985                                        break;
6986                                case LEADING_ASTERISK:
6987                                        {
6988                                        setState(862);
6989                                        match(LEADING_ASTERISK);
6990                                        }
6991                                        break;
6992                                case WS:
6993                                        {
6994                                        setState(863);
6995                                        match(WS);
6996                                        }
6997                                        break;
6998                                default:
6999                                        throw new NoViableAltException(this);
7000                                }
7001                                }
7002                                setState(868);
7003                                _errHandler.sync(this);
7004                                _la = _input.LA(1);
7005                        }
7006                        setState(869);
7007                        match(CLOSE);
7008                        }
7009                }
7010                catch (RecognitionException re) {
7011                        _localctx.exception = re;
7012                        _errHandler.reportError(this, re);
7013                        _errHandler.recover(this, re);
7014                }
7015                finally {
7016                        exitRule();
7017                }
7018                return _localctx;
7019        }
7020
7021        public static class DtTagCloseContext extends ParserRuleContext {
7022                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7023                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7024                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
7025                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7026                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7027                public TerminalNode NEWLINE(int i) {
7028                        return getToken(JavadocParser.NEWLINE, i);
7029                }
7030                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7031                public TerminalNode LEADING_ASTERISK(int i) {
7032                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7033                }
7034                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7035                public TerminalNode WS(int i) {
7036                        return getToken(JavadocParser.WS, i);
7037                }
7038                public DtTagCloseContext(ParserRuleContext parent, int invokingState) {
7039                        super(parent, invokingState);
7040                }
7041                @Override public int getRuleIndex() { return RULE_dtTagClose; }
7042                @Override
7043                public void enterRule(ParseTreeListener listener) {
7044                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this);
7045                }
7046                @Override
7047                public void exitRule(ParseTreeListener listener) {
7048                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this);
7049                }
7050                @Override
7051                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7052                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this);
7053                        else return visitor.visitChildren(this);
7054                }
7055        }
7056
7057        public final DtTagCloseContext dtTagClose() throws RecognitionException {
7058                DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState());
7059                enterRule(_localctx, 62, RULE_dtTagClose);
7060                int _la;
7061                try {
7062                        enterOuterAlt(_localctx, 1);
7063                        {
7064                        setState(871);
7065                        match(OPEN);
7066                        setState(872);
7067                        match(SLASH);
7068                        setState(873);
7069                        match(DT_HTML_TAG_NAME);
7070                        setState(877);
7071                        _errHandler.sync(this);
7072                        _la = _input.LA(1);
7073                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7074                                {
7075                                {
7076                                setState(874);
7077                                _la = _input.LA(1);
7078                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7079                                _errHandler.recoverInline(this);
7080                                } else {
7081                                        consume();
7082                                }
7083                                }
7084                                }
7085                                setState(879);
7086                                _errHandler.sync(this);
7087                                _la = _input.LA(1);
7088                        }
7089                        setState(880);
7090                        match(CLOSE);
7091                        }
7092                }
7093                catch (RecognitionException re) {
7094                        _localctx.exception = re;
7095                        _errHandler.reportError(this, re);
7096                        _errHandler.recover(this, re);
7097                }
7098                finally {
7099                        exitRule();
7100                }
7101                return _localctx;
7102        }
7103
7104        public static class DtContext extends ParserRuleContext {
7105                public DtTagOpenContext dtTagOpen() {
7106                        return getRuleContext(DtTagOpenContext.class,0);
7107                }
7108                public DtTagCloseContext dtTagClose() {
7109                        return getRuleContext(DtTagCloseContext.class,0);
7110                }
7111                public List<HtmlTagContext> htmlTag() {
7112                        return getRuleContexts(HtmlTagContext.class);
7113                }
7114                public HtmlTagContext htmlTag(int i) {
7115                        return getRuleContext(HtmlTagContext.class,i);
7116                }
7117                public List<SingletonTagContext> singletonTag() {
7118                        return getRuleContexts(SingletonTagContext.class);
7119                }
7120                public SingletonTagContext singletonTag(int i) {
7121                        return getRuleContext(SingletonTagContext.class,i);
7122                }
7123                public List<ParagraphContext> paragraph() {
7124                        return getRuleContexts(ParagraphContext.class);
7125                }
7126                public ParagraphContext paragraph(int i) {
7127                        return getRuleContext(ParagraphContext.class,i);
7128                }
7129                public List<LiContext> li() {
7130                        return getRuleContexts(LiContext.class);
7131                }
7132                public LiContext li(int i) {
7133                        return getRuleContext(LiContext.class,i);
7134                }
7135                public List<TrContext> tr() {
7136                        return getRuleContexts(TrContext.class);
7137                }
7138                public TrContext tr(int i) {
7139                        return getRuleContext(TrContext.class,i);
7140                }
7141                public List<TdContext> td() {
7142                        return getRuleContexts(TdContext.class);
7143                }
7144                public TdContext td(int i) {
7145                        return getRuleContext(TdContext.class,i);
7146                }
7147                public List<ThContext> th() {
7148                        return getRuleContexts(ThContext.class);
7149                }
7150                public ThContext th(int i) {
7151                        return getRuleContext(ThContext.class,i);
7152                }
7153                public List<BodyContext> body() {
7154                        return getRuleContexts(BodyContext.class);
7155                }
7156                public BodyContext body(int i) {
7157                        return getRuleContext(BodyContext.class,i);
7158                }
7159                public List<ColgroupContext> colgroup() {
7160                        return getRuleContexts(ColgroupContext.class);
7161                }
7162                public ColgroupContext colgroup(int i) {
7163                        return getRuleContext(ColgroupContext.class,i);
7164                }
7165                public List<DdContext> dd() {
7166                        return getRuleContexts(DdContext.class);
7167                }
7168                public DdContext dd(int i) {
7169                        return getRuleContext(DdContext.class,i);
7170                }
7171                public List<HeadContext> head() {
7172                        return getRuleContexts(HeadContext.class);
7173                }
7174                public HeadContext head(int i) {
7175                        return getRuleContext(HeadContext.class,i);
7176                }
7177                public List<HtmlContext> html() {
7178                        return getRuleContexts(HtmlContext.class);
7179                }
7180                public HtmlContext html(int i) {
7181                        return getRuleContext(HtmlContext.class,i);
7182                }
7183                public List<OptionContext> option() {
7184                        return getRuleContexts(OptionContext.class);
7185                }
7186                public OptionContext option(int i) {
7187                        return getRuleContext(OptionContext.class,i);
7188                }
7189                public List<TbodyContext> tbody() {
7190                        return getRuleContexts(TbodyContext.class);
7191                }
7192                public TbodyContext tbody(int i) {
7193                        return getRuleContext(TbodyContext.class,i);
7194                }
7195                public List<TheadContext> thead() {
7196                        return getRuleContexts(TheadContext.class);
7197                }
7198                public TheadContext thead(int i) {
7199                        return getRuleContext(TheadContext.class,i);
7200                }
7201                public List<TfootContext> tfoot() {
7202                        return getRuleContexts(TfootContext.class);
7203                }
7204                public TfootContext tfoot(int i) {
7205                        return getRuleContext(TfootContext.class,i);
7206                }
7207                public List<PTagOpenContext> pTagOpen() {
7208                        return getRuleContexts(PTagOpenContext.class);
7209                }
7210                public PTagOpenContext pTagOpen(int i) {
7211                        return getRuleContext(PTagOpenContext.class,i);
7212                }
7213                public List<LiTagOpenContext> liTagOpen() {
7214                        return getRuleContexts(LiTagOpenContext.class);
7215                }
7216                public LiTagOpenContext liTagOpen(int i) {
7217                        return getRuleContext(LiTagOpenContext.class,i);
7218                }
7219                public List<TrTagOpenContext> trTagOpen() {
7220                        return getRuleContexts(TrTagOpenContext.class);
7221                }
7222                public TrTagOpenContext trTagOpen(int i) {
7223                        return getRuleContext(TrTagOpenContext.class,i);
7224                }
7225                public List<TdTagOpenContext> tdTagOpen() {
7226                        return getRuleContexts(TdTagOpenContext.class);
7227                }
7228                public TdTagOpenContext tdTagOpen(int i) {
7229                        return getRuleContext(TdTagOpenContext.class,i);
7230                }
7231                public List<ThTagOpenContext> thTagOpen() {
7232                        return getRuleContexts(ThTagOpenContext.class);
7233                }
7234                public ThTagOpenContext thTagOpen(int i) {
7235                        return getRuleContext(ThTagOpenContext.class,i);
7236                }
7237                public List<BodyTagOpenContext> bodyTagOpen() {
7238                        return getRuleContexts(BodyTagOpenContext.class);
7239                }
7240                public BodyTagOpenContext bodyTagOpen(int i) {
7241                        return getRuleContext(BodyTagOpenContext.class,i);
7242                }
7243                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7244                        return getRuleContexts(ColgroupTagOpenContext.class);
7245                }
7246                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7247                        return getRuleContext(ColgroupTagOpenContext.class,i);
7248                }
7249                public List<DdTagOpenContext> ddTagOpen() {
7250                        return getRuleContexts(DdTagOpenContext.class);
7251                }
7252                public DdTagOpenContext ddTagOpen(int i) {
7253                        return getRuleContext(DdTagOpenContext.class,i);
7254                }
7255                public List<HeadTagOpenContext> headTagOpen() {
7256                        return getRuleContexts(HeadTagOpenContext.class);
7257                }
7258                public HeadTagOpenContext headTagOpen(int i) {
7259                        return getRuleContext(HeadTagOpenContext.class,i);
7260                }
7261                public List<HtmlTagOpenContext> htmlTagOpen() {
7262                        return getRuleContexts(HtmlTagOpenContext.class);
7263                }
7264                public HtmlTagOpenContext htmlTagOpen(int i) {
7265                        return getRuleContext(HtmlTagOpenContext.class,i);
7266                }
7267                public List<OptionTagOpenContext> optionTagOpen() {
7268                        return getRuleContexts(OptionTagOpenContext.class);
7269                }
7270                public OptionTagOpenContext optionTagOpen(int i) {
7271                        return getRuleContext(OptionTagOpenContext.class,i);
7272                }
7273                public List<TbodyTagOpenContext> tbodyTagOpen() {
7274                        return getRuleContexts(TbodyTagOpenContext.class);
7275                }
7276                public TbodyTagOpenContext tbodyTagOpen(int i) {
7277                        return getRuleContext(TbodyTagOpenContext.class,i);
7278                }
7279                public List<TheadTagOpenContext> theadTagOpen() {
7280                        return getRuleContexts(TheadTagOpenContext.class);
7281                }
7282                public TheadTagOpenContext theadTagOpen(int i) {
7283                        return getRuleContext(TheadTagOpenContext.class,i);
7284                }
7285                public List<TfootTagOpenContext> tfootTagOpen() {
7286                        return getRuleContexts(TfootTagOpenContext.class);
7287                }
7288                public TfootTagOpenContext tfootTagOpen(int i) {
7289                        return getRuleContext(TfootTagOpenContext.class,i);
7290                }
7291                public List<HtmlCommentContext> htmlComment() {
7292                        return getRuleContexts(HtmlCommentContext.class);
7293                }
7294                public HtmlCommentContext htmlComment(int i) {
7295                        return getRuleContext(HtmlCommentContext.class,i);
7296                }
7297                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7298                public TerminalNode CDATA(int i) {
7299                        return getToken(JavadocParser.CDATA, i);
7300                }
7301                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7302                public TerminalNode NEWLINE(int i) {
7303                        return getToken(JavadocParser.NEWLINE, i);
7304                }
7305                public List<TextContext> text() {
7306                        return getRuleContexts(TextContext.class);
7307                }
7308                public TextContext text(int i) {
7309                        return getRuleContext(TextContext.class,i);
7310                }
7311                public List<JavadocInlineTagContext> javadocInlineTag() {
7312                        return getRuleContexts(JavadocInlineTagContext.class);
7313                }
7314                public JavadocInlineTagContext javadocInlineTag(int i) {
7315                        return getRuleContext(JavadocInlineTagContext.class,i);
7316                }
7317                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7318                public TerminalNode LEADING_ASTERISK(int i) {
7319                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7320                }
7321                public DtContext(ParserRuleContext parent, int invokingState) {
7322                        super(parent, invokingState);
7323                }
7324                @Override public int getRuleIndex() { return RULE_dt; }
7325                @Override
7326                public void enterRule(ParseTreeListener listener) {
7327                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this);
7328                }
7329                @Override
7330                public void exitRule(ParseTreeListener listener) {
7331                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this);
7332                }
7333                @Override
7334                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7335                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this);
7336                        else return visitor.visitChildren(this);
7337                }
7338        }
7339
7340        public final DtContext dt() throws RecognitionException {
7341                DtContext _localctx = new DtContext(_ctx, getState());
7342                enterRule(_localctx, 64, RULE_dt);
7343                try {
7344                        int _alt;
7345                        enterOuterAlt(_localctx, 1);
7346                        {
7347                        setState(882);
7348                        dtTagOpen();
7349                        setState(922);
7350                        _errHandler.sync(this);
7351                        _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7352                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7353                                if ( _alt==1 ) {
7354                                        {
7355                                        setState(920);
7356                                        _errHandler.sync(this);
7357                                        switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
7358                                        case 1:
7359                                                {
7360                                                setState(883);
7361                                                htmlTag();
7362                                                }
7363                                                break;
7364                                        case 2:
7365                                                {
7366                                                setState(884);
7367                                                singletonTag();
7368                                                }
7369                                                break;
7370                                        case 3:
7371                                                {
7372                                                setState(885);
7373                                                paragraph();
7374                                                }
7375                                                break;
7376                                        case 4:
7377                                                {
7378                                                setState(886);
7379                                                li();
7380                                                }
7381                                                break;
7382                                        case 5:
7383                                                {
7384                                                setState(887);
7385                                                tr();
7386                                                }
7387                                                break;
7388                                        case 6:
7389                                                {
7390                                                setState(888);
7391                                                td();
7392                                                }
7393                                                break;
7394                                        case 7:
7395                                                {
7396                                                setState(889);
7397                                                th();
7398                                                }
7399                                                break;
7400                                        case 8:
7401                                                {
7402                                                setState(890);
7403                                                body();
7404                                                }
7405                                                break;
7406                                        case 9:
7407                                                {
7408                                                setState(891);
7409                                                colgroup();
7410                                                }
7411                                                break;
7412                                        case 10:
7413                                                {
7414                                                setState(892);
7415                                                dd();
7416                                                }
7417                                                break;
7418                                        case 11:
7419                                                {
7420                                                setState(893);
7421                                                head();
7422                                                }
7423                                                break;
7424                                        case 12:
7425                                                {
7426                                                setState(894);
7427                                                html();
7428                                                }
7429                                                break;
7430                                        case 13:
7431                                                {
7432                                                setState(895);
7433                                                option();
7434                                                }
7435                                                break;
7436                                        case 14:
7437                                                {
7438                                                setState(896);
7439                                                tbody();
7440                                                }
7441                                                break;
7442                                        case 15:
7443                                                {
7444                                                setState(897);
7445                                                thead();
7446                                                }
7447                                                break;
7448                                        case 16:
7449                                                {
7450                                                setState(898);
7451                                                tfoot();
7452                                                }
7453                                                break;
7454                                        case 17:
7455                                                {
7456                                                setState(899);
7457                                                pTagOpen();
7458                                                }
7459                                                break;
7460                                        case 18:
7461                                                {
7462                                                setState(900);
7463                                                liTagOpen();
7464                                                }
7465                                                break;
7466                                        case 19:
7467                                                {
7468                                                setState(901);
7469                                                trTagOpen();
7470                                                }
7471                                                break;
7472                                        case 20:
7473                                                {
7474                                                setState(902);
7475                                                tdTagOpen();
7476                                                }
7477                                                break;
7478                                        case 21:
7479                                                {
7480                                                setState(903);
7481                                                thTagOpen();
7482                                                }
7483                                                break;
7484                                        case 22:
7485                                                {
7486                                                setState(904);
7487                                                bodyTagOpen();
7488                                                }
7489                                                break;
7490                                        case 23:
7491                                                {
7492                                                setState(905);
7493                                                colgroupTagOpen();
7494                                                }
7495                                                break;
7496                                        case 24:
7497                                                {
7498                                                setState(906);
7499                                                ddTagOpen();
7500                                                }
7501                                                break;
7502                                        case 25:
7503                                                {
7504                                                setState(907);
7505                                                headTagOpen();
7506                                                }
7507                                                break;
7508                                        case 26:
7509                                                {
7510                                                setState(908);
7511                                                htmlTagOpen();
7512                                                }
7513                                                break;
7514                                        case 27:
7515                                                {
7516                                                setState(909);
7517                                                optionTagOpen();
7518                                                }
7519                                                break;
7520                                        case 28:
7521                                                {
7522                                                setState(910);
7523                                                tbodyTagOpen();
7524                                                }
7525                                                break;
7526                                        case 29:
7527                                                {
7528                                                setState(911);
7529                                                theadTagOpen();
7530                                                }
7531                                                break;
7532                                        case 30:
7533                                                {
7534                                                setState(912);
7535                                                tfootTagOpen();
7536                                                }
7537                                                break;
7538                                        case 31:
7539                                                {
7540                                                {
7541                                                setState(913);
7542                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
7543                                                setState(914);
7544                                                match(LEADING_ASTERISK);
7545                                                }
7546                                                }
7547                                                break;
7548                                        case 32:
7549                                                {
7550                                                setState(915);
7551                                                htmlComment();
7552                                                }
7553                                                break;
7554                                        case 33:
7555                                                {
7556                                                setState(916);
7557                                                match(CDATA);
7558                                                }
7559                                                break;
7560                                        case 34:
7561                                                {
7562                                                setState(917);
7563                                                match(NEWLINE);
7564                                                }
7565                                                break;
7566                                        case 35:
7567                                                {
7568                                                setState(918);
7569                                                text();
7570                                                }
7571                                                break;
7572                                        case 36:
7573                                                {
7574                                                setState(919);
7575                                                javadocInlineTag();
7576                                                }
7577                                                break;
7578                                        }
7579                                        } 
7580                                }
7581                                setState(924);
7582                                _errHandler.sync(this);
7583                                _alt = getInterpreter().adaptivePredict(_input,61,_ctx);
7584                        }
7585                        setState(925);
7586                        dtTagClose();
7587                        }
7588                }
7589                catch (RecognitionException re) {
7590                        _localctx.exception = re;
7591                        _errHandler.reportError(this, re);
7592                        _errHandler.recover(this, re);
7593                }
7594                finally {
7595                        exitRule();
7596                }
7597                return _localctx;
7598        }
7599
7600        public static class HeadTagOpenContext extends ParserRuleContext {
7601                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7602                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7603                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7604                public List<AttributeContext> attribute() {
7605                        return getRuleContexts(AttributeContext.class);
7606                }
7607                public AttributeContext attribute(int i) {
7608                        return getRuleContext(AttributeContext.class,i);
7609                }
7610                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7611                public TerminalNode NEWLINE(int i) {
7612                        return getToken(JavadocParser.NEWLINE, i);
7613                }
7614                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7615                public TerminalNode LEADING_ASTERISK(int i) {
7616                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7617                }
7618                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7619                public TerminalNode WS(int i) {
7620                        return getToken(JavadocParser.WS, i);
7621                }
7622                public HeadTagOpenContext(ParserRuleContext parent, int invokingState) {
7623                        super(parent, invokingState);
7624                }
7625                @Override public int getRuleIndex() { return RULE_headTagOpen; }
7626                @Override
7627                public void enterRule(ParseTreeListener listener) {
7628                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this);
7629                }
7630                @Override
7631                public void exitRule(ParseTreeListener listener) {
7632                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this);
7633                }
7634                @Override
7635                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7636                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this);
7637                        else return visitor.visitChildren(this);
7638                }
7639        }
7640
7641        public final HeadTagOpenContext headTagOpen() throws RecognitionException {
7642                HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState());
7643                enterRule(_localctx, 66, RULE_headTagOpen);
7644                int _la;
7645                try {
7646                        enterOuterAlt(_localctx, 1);
7647                        {
7648                        setState(927);
7649                        match(OPEN);
7650                        setState(928);
7651                        match(HEAD_HTML_TAG_NAME);
7652                        setState(935);
7653                        _errHandler.sync(this);
7654                        _la = _input.LA(1);
7655                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
7656                                {
7657                                setState(933);
7658                                switch (_input.LA(1)) {
7659                                case HTML_TAG_NAME:
7660                                        {
7661                                        setState(929);
7662                                        attribute();
7663                                        }
7664                                        break;
7665                                case NEWLINE:
7666                                        {
7667                                        setState(930);
7668                                        match(NEWLINE);
7669                                        }
7670                                        break;
7671                                case LEADING_ASTERISK:
7672                                        {
7673                                        setState(931);
7674                                        match(LEADING_ASTERISK);
7675                                        }
7676                                        break;
7677                                case WS:
7678                                        {
7679                                        setState(932);
7680                                        match(WS);
7681                                        }
7682                                        break;
7683                                default:
7684                                        throw new NoViableAltException(this);
7685                                }
7686                                }
7687                                setState(937);
7688                                _errHandler.sync(this);
7689                                _la = _input.LA(1);
7690                        }
7691                        setState(938);
7692                        match(CLOSE);
7693                        }
7694                }
7695                catch (RecognitionException re) {
7696                        _localctx.exception = re;
7697                        _errHandler.reportError(this, re);
7698                        _errHandler.recover(this, re);
7699                }
7700                finally {
7701                        exitRule();
7702                }
7703                return _localctx;
7704        }
7705
7706        public static class HeadTagCloseContext extends ParserRuleContext {
7707                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
7708                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
7709                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
7710                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
7711                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7712                public TerminalNode NEWLINE(int i) {
7713                        return getToken(JavadocParser.NEWLINE, i);
7714                }
7715                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
7716                public TerminalNode LEADING_ASTERISK(int i) {
7717                        return getToken(JavadocParser.LEADING_ASTERISK, i);
7718                }
7719                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
7720                public TerminalNode WS(int i) {
7721                        return getToken(JavadocParser.WS, i);
7722                }
7723                public HeadTagCloseContext(ParserRuleContext parent, int invokingState) {
7724                        super(parent, invokingState);
7725                }
7726                @Override public int getRuleIndex() { return RULE_headTagClose; }
7727                @Override
7728                public void enterRule(ParseTreeListener listener) {
7729                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this);
7730                }
7731                @Override
7732                public void exitRule(ParseTreeListener listener) {
7733                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this);
7734                }
7735                @Override
7736                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
7737                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this);
7738                        else return visitor.visitChildren(this);
7739                }
7740        }
7741
7742        public final HeadTagCloseContext headTagClose() throws RecognitionException {
7743                HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState());
7744                enterRule(_localctx, 68, RULE_headTagClose);
7745                int _la;
7746                try {
7747                        enterOuterAlt(_localctx, 1);
7748                        {
7749                        setState(940);
7750                        match(OPEN);
7751                        setState(941);
7752                        match(SLASH);
7753                        setState(942);
7754                        match(HEAD_HTML_TAG_NAME);
7755                        setState(946);
7756                        _errHandler.sync(this);
7757                        _la = _input.LA(1);
7758                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
7759                                {
7760                                {
7761                                setState(943);
7762                                _la = _input.LA(1);
7763                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
7764                                _errHandler.recoverInline(this);
7765                                } else {
7766                                        consume();
7767                                }
7768                                }
7769                                }
7770                                setState(948);
7771                                _errHandler.sync(this);
7772                                _la = _input.LA(1);
7773                        }
7774                        setState(949);
7775                        match(CLOSE);
7776                        }
7777                }
7778                catch (RecognitionException re) {
7779                        _localctx.exception = re;
7780                        _errHandler.reportError(this, re);
7781                        _errHandler.recover(this, re);
7782                }
7783                finally {
7784                        exitRule();
7785                }
7786                return _localctx;
7787        }
7788
7789        public static class HeadContext extends ParserRuleContext {
7790                public HeadTagOpenContext headTagOpen() {
7791                        return getRuleContext(HeadTagOpenContext.class,0);
7792                }
7793                public HeadTagCloseContext headTagClose() {
7794                        return getRuleContext(HeadTagCloseContext.class,0);
7795                }
7796                public List<HtmlTagContext> htmlTag() {
7797                        return getRuleContexts(HtmlTagContext.class);
7798                }
7799                public HtmlTagContext htmlTag(int i) {
7800                        return getRuleContext(HtmlTagContext.class,i);
7801                }
7802                public List<SingletonTagContext> singletonTag() {
7803                        return getRuleContexts(SingletonTagContext.class);
7804                }
7805                public SingletonTagContext singletonTag(int i) {
7806                        return getRuleContext(SingletonTagContext.class,i);
7807                }
7808                public List<ParagraphContext> paragraph() {
7809                        return getRuleContexts(ParagraphContext.class);
7810                }
7811                public ParagraphContext paragraph(int i) {
7812                        return getRuleContext(ParagraphContext.class,i);
7813                }
7814                public List<LiContext> li() {
7815                        return getRuleContexts(LiContext.class);
7816                }
7817                public LiContext li(int i) {
7818                        return getRuleContext(LiContext.class,i);
7819                }
7820                public List<TrContext> tr() {
7821                        return getRuleContexts(TrContext.class);
7822                }
7823                public TrContext tr(int i) {
7824                        return getRuleContext(TrContext.class,i);
7825                }
7826                public List<TdContext> td() {
7827                        return getRuleContexts(TdContext.class);
7828                }
7829                public TdContext td(int i) {
7830                        return getRuleContext(TdContext.class,i);
7831                }
7832                public List<ThContext> th() {
7833                        return getRuleContexts(ThContext.class);
7834                }
7835                public ThContext th(int i) {
7836                        return getRuleContext(ThContext.class,i);
7837                }
7838                public List<BodyContext> body() {
7839                        return getRuleContexts(BodyContext.class);
7840                }
7841                public BodyContext body(int i) {
7842                        return getRuleContext(BodyContext.class,i);
7843                }
7844                public List<ColgroupContext> colgroup() {
7845                        return getRuleContexts(ColgroupContext.class);
7846                }
7847                public ColgroupContext colgroup(int i) {
7848                        return getRuleContext(ColgroupContext.class,i);
7849                }
7850                public List<DdContext> dd() {
7851                        return getRuleContexts(DdContext.class);
7852                }
7853                public DdContext dd(int i) {
7854                        return getRuleContext(DdContext.class,i);
7855                }
7856                public List<DtContext> dt() {
7857                        return getRuleContexts(DtContext.class);
7858                }
7859                public DtContext dt(int i) {
7860                        return getRuleContext(DtContext.class,i);
7861                }
7862                public List<HtmlContext> html() {
7863                        return getRuleContexts(HtmlContext.class);
7864                }
7865                public HtmlContext html(int i) {
7866                        return getRuleContext(HtmlContext.class,i);
7867                }
7868                public List<OptionContext> option() {
7869                        return getRuleContexts(OptionContext.class);
7870                }
7871                public OptionContext option(int i) {
7872                        return getRuleContext(OptionContext.class,i);
7873                }
7874                public List<TbodyContext> tbody() {
7875                        return getRuleContexts(TbodyContext.class);
7876                }
7877                public TbodyContext tbody(int i) {
7878                        return getRuleContext(TbodyContext.class,i);
7879                }
7880                public List<TheadContext> thead() {
7881                        return getRuleContexts(TheadContext.class);
7882                }
7883                public TheadContext thead(int i) {
7884                        return getRuleContext(TheadContext.class,i);
7885                }
7886                public List<TfootContext> tfoot() {
7887                        return getRuleContexts(TfootContext.class);
7888                }
7889                public TfootContext tfoot(int i) {
7890                        return getRuleContext(TfootContext.class,i);
7891                }
7892                public List<PTagOpenContext> pTagOpen() {
7893                        return getRuleContexts(PTagOpenContext.class);
7894                }
7895                public PTagOpenContext pTagOpen(int i) {
7896                        return getRuleContext(PTagOpenContext.class,i);
7897                }
7898                public List<LiTagOpenContext> liTagOpen() {
7899                        return getRuleContexts(LiTagOpenContext.class);
7900                }
7901                public LiTagOpenContext liTagOpen(int i) {
7902                        return getRuleContext(LiTagOpenContext.class,i);
7903                }
7904                public List<TrTagOpenContext> trTagOpen() {
7905                        return getRuleContexts(TrTagOpenContext.class);
7906                }
7907                public TrTagOpenContext trTagOpen(int i) {
7908                        return getRuleContext(TrTagOpenContext.class,i);
7909                }
7910                public List<TdTagOpenContext> tdTagOpen() {
7911                        return getRuleContexts(TdTagOpenContext.class);
7912                }
7913                public TdTagOpenContext tdTagOpen(int i) {
7914                        return getRuleContext(TdTagOpenContext.class,i);
7915                }
7916                public List<ThTagOpenContext> thTagOpen() {
7917                        return getRuleContexts(ThTagOpenContext.class);
7918                }
7919                public ThTagOpenContext thTagOpen(int i) {
7920                        return getRuleContext(ThTagOpenContext.class,i);
7921                }
7922                public List<BodyTagOpenContext> bodyTagOpen() {
7923                        return getRuleContexts(BodyTagOpenContext.class);
7924                }
7925                public BodyTagOpenContext bodyTagOpen(int i) {
7926                        return getRuleContext(BodyTagOpenContext.class,i);
7927                }
7928                public List<ColgroupTagOpenContext> colgroupTagOpen() {
7929                        return getRuleContexts(ColgroupTagOpenContext.class);
7930                }
7931                public ColgroupTagOpenContext colgroupTagOpen(int i) {
7932                        return getRuleContext(ColgroupTagOpenContext.class,i);
7933                }
7934                public List<DdTagOpenContext> ddTagOpen() {
7935                        return getRuleContexts(DdTagOpenContext.class);
7936                }
7937                public DdTagOpenContext ddTagOpen(int i) {
7938                        return getRuleContext(DdTagOpenContext.class,i);
7939                }
7940                public List<DtTagOpenContext> dtTagOpen() {
7941                        return getRuleContexts(DtTagOpenContext.class);
7942                }
7943                public DtTagOpenContext dtTagOpen(int i) {
7944                        return getRuleContext(DtTagOpenContext.class,i);
7945                }
7946                public List<HtmlTagOpenContext> htmlTagOpen() {
7947                        return getRuleContexts(HtmlTagOpenContext.class);
7948                }
7949                public HtmlTagOpenContext htmlTagOpen(int i) {
7950                        return getRuleContext(HtmlTagOpenContext.class,i);
7951                }
7952                public List<OptionTagOpenContext> optionTagOpen() {
7953                        return getRuleContexts(OptionTagOpenContext.class);
7954                }
7955                public OptionTagOpenContext optionTagOpen(int i) {
7956                        return getRuleContext(OptionTagOpenContext.class,i);
7957                }
7958                public List<TbodyTagOpenContext> tbodyTagOpen() {
7959                        return getRuleContexts(TbodyTagOpenContext.class);
7960                }
7961                public TbodyTagOpenContext tbodyTagOpen(int i) {
7962                        return getRuleContext(TbodyTagOpenContext.class,i);
7963                }
7964                public List<TheadTagOpenContext> theadTagOpen() {
7965                        return getRuleContexts(TheadTagOpenContext.class);
7966                }
7967                public TheadTagOpenContext theadTagOpen(int i) {
7968                        return getRuleContext(TheadTagOpenContext.class,i);
7969                }
7970                public List<TfootTagOpenContext> tfootTagOpen() {
7971                        return getRuleContexts(TfootTagOpenContext.class);
7972                }
7973                public TfootTagOpenContext tfootTagOpen(int i) {
7974                        return getRuleContext(TfootTagOpenContext.class,i);
7975                }
7976                public List<HtmlCommentContext> htmlComment() {
7977                        return getRuleContexts(HtmlCommentContext.class);
7978                }
7979                public HtmlCommentContext htmlComment(int i) {
7980                        return getRuleContext(HtmlCommentContext.class,i);
7981                }
7982                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
7983                public TerminalNode CDATA(int i) {
7984                        return getToken(JavadocParser.CDATA, i);
7985                }
7986                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
7987                public TerminalNode NEWLINE(int i) {
7988                        return getToken(JavadocParser.NEWLINE, i);
7989                }
7990                public List<TextContext> text() {
7991                        return getRuleContexts(TextContext.class);
7992                }
7993                public TextContext text(int i) {
7994                        return getRuleContext(TextContext.class,i);
7995                }
7996                public List<JavadocInlineTagContext> javadocInlineTag() {
7997                        return getRuleContexts(JavadocInlineTagContext.class);
7998                }
7999                public JavadocInlineTagContext javadocInlineTag(int i) {
8000                        return getRuleContext(JavadocInlineTagContext.class,i);
8001                }
8002                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8003                public TerminalNode LEADING_ASTERISK(int i) {
8004                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8005                }
8006                public HeadContext(ParserRuleContext parent, int invokingState) {
8007                        super(parent, invokingState);
8008                }
8009                @Override public int getRuleIndex() { return RULE_head; }
8010                @Override
8011                public void enterRule(ParseTreeListener listener) {
8012                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this);
8013                }
8014                @Override
8015                public void exitRule(ParseTreeListener listener) {
8016                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this);
8017                }
8018                @Override
8019                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8020                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this);
8021                        else return visitor.visitChildren(this);
8022                }
8023        }
8024
8025        public final HeadContext head() throws RecognitionException {
8026                HeadContext _localctx = new HeadContext(_ctx, getState());
8027                enterRule(_localctx, 70, RULE_head);
8028                try {
8029                        int _alt;
8030                        enterOuterAlt(_localctx, 1);
8031                        {
8032                        setState(951);
8033                        headTagOpen();
8034                        setState(991);
8035                        _errHandler.sync(this);
8036                        _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8037                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8038                                if ( _alt==1 ) {
8039                                        {
8040                                        setState(989);
8041                                        _errHandler.sync(this);
8042                                        switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
8043                                        case 1:
8044                                                {
8045                                                setState(952);
8046                                                htmlTag();
8047                                                }
8048                                                break;
8049                                        case 2:
8050                                                {
8051                                                setState(953);
8052                                                singletonTag();
8053                                                }
8054                                                break;
8055                                        case 3:
8056                                                {
8057                                                setState(954);
8058                                                paragraph();
8059                                                }
8060                                                break;
8061                                        case 4:
8062                                                {
8063                                                setState(955);
8064                                                li();
8065                                                }
8066                                                break;
8067                                        case 5:
8068                                                {
8069                                                setState(956);
8070                                                tr();
8071                                                }
8072                                                break;
8073                                        case 6:
8074                                                {
8075                                                setState(957);
8076                                                td();
8077                                                }
8078                                                break;
8079                                        case 7:
8080                                                {
8081                                                setState(958);
8082                                                th();
8083                                                }
8084                                                break;
8085                                        case 8:
8086                                                {
8087                                                setState(959);
8088                                                body();
8089                                                }
8090                                                break;
8091                                        case 9:
8092                                                {
8093                                                setState(960);
8094                                                colgroup();
8095                                                }
8096                                                break;
8097                                        case 10:
8098                                                {
8099                                                setState(961);
8100                                                dd();
8101                                                }
8102                                                break;
8103                                        case 11:
8104                                                {
8105                                                setState(962);
8106                                                dt();
8107                                                }
8108                                                break;
8109                                        case 12:
8110                                                {
8111                                                setState(963);
8112                                                html();
8113                                                }
8114                                                break;
8115                                        case 13:
8116                                                {
8117                                                setState(964);
8118                                                option();
8119                                                }
8120                                                break;
8121                                        case 14:
8122                                                {
8123                                                setState(965);
8124                                                tbody();
8125                                                }
8126                                                break;
8127                                        case 15:
8128                                                {
8129                                                setState(966);
8130                                                thead();
8131                                                }
8132                                                break;
8133                                        case 16:
8134                                                {
8135                                                setState(967);
8136                                                tfoot();
8137                                                }
8138                                                break;
8139                                        case 17:
8140                                                {
8141                                                setState(968);
8142                                                pTagOpen();
8143                                                }
8144                                                break;
8145                                        case 18:
8146                                                {
8147                                                setState(969);
8148                                                liTagOpen();
8149                                                }
8150                                                break;
8151                                        case 19:
8152                                                {
8153                                                setState(970);
8154                                                trTagOpen();
8155                                                }
8156                                                break;
8157                                        case 20:
8158                                                {
8159                                                setState(971);
8160                                                tdTagOpen();
8161                                                }
8162                                                break;
8163                                        case 21:
8164                                                {
8165                                                setState(972);
8166                                                thTagOpen();
8167                                                }
8168                                                break;
8169                                        case 22:
8170                                                {
8171                                                setState(973);
8172                                                bodyTagOpen();
8173                                                }
8174                                                break;
8175                                        case 23:
8176                                                {
8177                                                setState(974);
8178                                                colgroupTagOpen();
8179                                                }
8180                                                break;
8181                                        case 24:
8182                                                {
8183                                                setState(975);
8184                                                ddTagOpen();
8185                                                }
8186                                                break;
8187                                        case 25:
8188                                                {
8189                                                setState(976);
8190                                                dtTagOpen();
8191                                                }
8192                                                break;
8193                                        case 26:
8194                                                {
8195                                                setState(977);
8196                                                htmlTagOpen();
8197                                                }
8198                                                break;
8199                                        case 27:
8200                                                {
8201                                                setState(978);
8202                                                optionTagOpen();
8203                                                }
8204                                                break;
8205                                        case 28:
8206                                                {
8207                                                setState(979);
8208                                                tbodyTagOpen();
8209                                                }
8210                                                break;
8211                                        case 29:
8212                                                {
8213                                                setState(980);
8214                                                theadTagOpen();
8215                                                }
8216                                                break;
8217                                        case 30:
8218                                                {
8219                                                setState(981);
8220                                                tfootTagOpen();
8221                                                }
8222                                                break;
8223                                        case 31:
8224                                                {
8225                                                {
8226                                                setState(982);
8227                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8228                                                setState(983);
8229                                                match(LEADING_ASTERISK);
8230                                                }
8231                                                }
8232                                                break;
8233                                        case 32:
8234                                                {
8235                                                setState(984);
8236                                                htmlComment();
8237                                                }
8238                                                break;
8239                                        case 33:
8240                                                {
8241                                                setState(985);
8242                                                match(CDATA);
8243                                                }
8244                                                break;
8245                                        case 34:
8246                                                {
8247                                                setState(986);
8248                                                match(NEWLINE);
8249                                                }
8250                                                break;
8251                                        case 35:
8252                                                {
8253                                                setState(987);
8254                                                text();
8255                                                }
8256                                                break;
8257                                        case 36:
8258                                                {
8259                                                setState(988);
8260                                                javadocInlineTag();
8261                                                }
8262                                                break;
8263                                        }
8264                                        } 
8265                                }
8266                                setState(993);
8267                                _errHandler.sync(this);
8268                                _alt = getInterpreter().adaptivePredict(_input,66,_ctx);
8269                        }
8270                        setState(994);
8271                        headTagClose();
8272                        }
8273                }
8274                catch (RecognitionException re) {
8275                        _localctx.exception = re;
8276                        _errHandler.reportError(this, re);
8277                        _errHandler.recover(this, re);
8278                }
8279                finally {
8280                        exitRule();
8281                }
8282                return _localctx;
8283        }
8284
8285        public static class HtmlTagOpenContext extends ParserRuleContext {
8286                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8287                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8288                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8289                public List<AttributeContext> attribute() {
8290                        return getRuleContexts(AttributeContext.class);
8291                }
8292                public AttributeContext attribute(int i) {
8293                        return getRuleContext(AttributeContext.class,i);
8294                }
8295                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8296                public TerminalNode NEWLINE(int i) {
8297                        return getToken(JavadocParser.NEWLINE, i);
8298                }
8299                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8300                public TerminalNode LEADING_ASTERISK(int i) {
8301                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8302                }
8303                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8304                public TerminalNode WS(int i) {
8305                        return getToken(JavadocParser.WS, i);
8306                }
8307                public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) {
8308                        super(parent, invokingState);
8309                }
8310                @Override public int getRuleIndex() { return RULE_htmlTagOpen; }
8311                @Override
8312                public void enterRule(ParseTreeListener listener) {
8313                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this);
8314                }
8315                @Override
8316                public void exitRule(ParseTreeListener listener) {
8317                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this);
8318                }
8319                @Override
8320                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8321                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this);
8322                        else return visitor.visitChildren(this);
8323                }
8324        }
8325
8326        public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException {
8327                HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState());
8328                enterRule(_localctx, 72, RULE_htmlTagOpen);
8329                int _la;
8330                try {
8331                        enterOuterAlt(_localctx, 1);
8332                        {
8333                        setState(996);
8334                        match(OPEN);
8335                        setState(997);
8336                        match(HTML_HTML_TAG_NAME);
8337                        setState(1004);
8338                        _errHandler.sync(this);
8339                        _la = _input.LA(1);
8340                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
8341                                {
8342                                setState(1002);
8343                                switch (_input.LA(1)) {
8344                                case HTML_TAG_NAME:
8345                                        {
8346                                        setState(998);
8347                                        attribute();
8348                                        }
8349                                        break;
8350                                case NEWLINE:
8351                                        {
8352                                        setState(999);
8353                                        match(NEWLINE);
8354                                        }
8355                                        break;
8356                                case LEADING_ASTERISK:
8357                                        {
8358                                        setState(1000);
8359                                        match(LEADING_ASTERISK);
8360                                        }
8361                                        break;
8362                                case WS:
8363                                        {
8364                                        setState(1001);
8365                                        match(WS);
8366                                        }
8367                                        break;
8368                                default:
8369                                        throw new NoViableAltException(this);
8370                                }
8371                                }
8372                                setState(1006);
8373                                _errHandler.sync(this);
8374                                _la = _input.LA(1);
8375                        }
8376                        setState(1007);
8377                        match(CLOSE);
8378                        }
8379                }
8380                catch (RecognitionException re) {
8381                        _localctx.exception = re;
8382                        _errHandler.reportError(this, re);
8383                        _errHandler.recover(this, re);
8384                }
8385                finally {
8386                        exitRule();
8387                }
8388                return _localctx;
8389        }
8390
8391        public static class HtmlTagCloseContext extends ParserRuleContext {
8392                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8393                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
8394                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
8395                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8396                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8397                public TerminalNode NEWLINE(int i) {
8398                        return getToken(JavadocParser.NEWLINE, i);
8399                }
8400                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8401                public TerminalNode LEADING_ASTERISK(int i) {
8402                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8403                }
8404                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8405                public TerminalNode WS(int i) {
8406                        return getToken(JavadocParser.WS, i);
8407                }
8408                public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) {
8409                        super(parent, invokingState);
8410                }
8411                @Override public int getRuleIndex() { return RULE_htmlTagClose; }
8412                @Override
8413                public void enterRule(ParseTreeListener listener) {
8414                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this);
8415                }
8416                @Override
8417                public void exitRule(ParseTreeListener listener) {
8418                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this);
8419                }
8420                @Override
8421                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8422                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this);
8423                        else return visitor.visitChildren(this);
8424                }
8425        }
8426
8427        public final HtmlTagCloseContext htmlTagClose() throws RecognitionException {
8428                HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState());
8429                enterRule(_localctx, 74, RULE_htmlTagClose);
8430                int _la;
8431                try {
8432                        enterOuterAlt(_localctx, 1);
8433                        {
8434                        setState(1009);
8435                        match(OPEN);
8436                        setState(1010);
8437                        match(SLASH);
8438                        setState(1011);
8439                        match(HTML_HTML_TAG_NAME);
8440                        setState(1015);
8441                        _errHandler.sync(this);
8442                        _la = _input.LA(1);
8443                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
8444                                {
8445                                {
8446                                setState(1012);
8447                                _la = _input.LA(1);
8448                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
8449                                _errHandler.recoverInline(this);
8450                                } else {
8451                                        consume();
8452                                }
8453                                }
8454                                }
8455                                setState(1017);
8456                                _errHandler.sync(this);
8457                                _la = _input.LA(1);
8458                        }
8459                        setState(1018);
8460                        match(CLOSE);
8461                        }
8462                }
8463                catch (RecognitionException re) {
8464                        _localctx.exception = re;
8465                        _errHandler.reportError(this, re);
8466                        _errHandler.recover(this, re);
8467                }
8468                finally {
8469                        exitRule();
8470                }
8471                return _localctx;
8472        }
8473
8474        public static class HtmlContext extends ParserRuleContext {
8475                public HtmlTagOpenContext htmlTagOpen() {
8476                        return getRuleContext(HtmlTagOpenContext.class,0);
8477                }
8478                public HtmlTagCloseContext htmlTagClose() {
8479                        return getRuleContext(HtmlTagCloseContext.class,0);
8480                }
8481                public List<HtmlTagContext> htmlTag() {
8482                        return getRuleContexts(HtmlTagContext.class);
8483                }
8484                public HtmlTagContext htmlTag(int i) {
8485                        return getRuleContext(HtmlTagContext.class,i);
8486                }
8487                public List<SingletonTagContext> singletonTag() {
8488                        return getRuleContexts(SingletonTagContext.class);
8489                }
8490                public SingletonTagContext singletonTag(int i) {
8491                        return getRuleContext(SingletonTagContext.class,i);
8492                }
8493                public List<ParagraphContext> paragraph() {
8494                        return getRuleContexts(ParagraphContext.class);
8495                }
8496                public ParagraphContext paragraph(int i) {
8497                        return getRuleContext(ParagraphContext.class,i);
8498                }
8499                public List<LiContext> li() {
8500                        return getRuleContexts(LiContext.class);
8501                }
8502                public LiContext li(int i) {
8503                        return getRuleContext(LiContext.class,i);
8504                }
8505                public List<TrContext> tr() {
8506                        return getRuleContexts(TrContext.class);
8507                }
8508                public TrContext tr(int i) {
8509                        return getRuleContext(TrContext.class,i);
8510                }
8511                public List<TdContext> td() {
8512                        return getRuleContexts(TdContext.class);
8513                }
8514                public TdContext td(int i) {
8515                        return getRuleContext(TdContext.class,i);
8516                }
8517                public List<ThContext> th() {
8518                        return getRuleContexts(ThContext.class);
8519                }
8520                public ThContext th(int i) {
8521                        return getRuleContext(ThContext.class,i);
8522                }
8523                public List<BodyContext> body() {
8524                        return getRuleContexts(BodyContext.class);
8525                }
8526                public BodyContext body(int i) {
8527                        return getRuleContext(BodyContext.class,i);
8528                }
8529                public List<ColgroupContext> colgroup() {
8530                        return getRuleContexts(ColgroupContext.class);
8531                }
8532                public ColgroupContext colgroup(int i) {
8533                        return getRuleContext(ColgroupContext.class,i);
8534                }
8535                public List<DdContext> dd() {
8536                        return getRuleContexts(DdContext.class);
8537                }
8538                public DdContext dd(int i) {
8539                        return getRuleContext(DdContext.class,i);
8540                }
8541                public List<DtContext> dt() {
8542                        return getRuleContexts(DtContext.class);
8543                }
8544                public DtContext dt(int i) {
8545                        return getRuleContext(DtContext.class,i);
8546                }
8547                public List<HeadContext> head() {
8548                        return getRuleContexts(HeadContext.class);
8549                }
8550                public HeadContext head(int i) {
8551                        return getRuleContext(HeadContext.class,i);
8552                }
8553                public List<OptionContext> option() {
8554                        return getRuleContexts(OptionContext.class);
8555                }
8556                public OptionContext option(int i) {
8557                        return getRuleContext(OptionContext.class,i);
8558                }
8559                public List<TbodyContext> tbody() {
8560                        return getRuleContexts(TbodyContext.class);
8561                }
8562                public TbodyContext tbody(int i) {
8563                        return getRuleContext(TbodyContext.class,i);
8564                }
8565                public List<TheadContext> thead() {
8566                        return getRuleContexts(TheadContext.class);
8567                }
8568                public TheadContext thead(int i) {
8569                        return getRuleContext(TheadContext.class,i);
8570                }
8571                public List<TfootContext> tfoot() {
8572                        return getRuleContexts(TfootContext.class);
8573                }
8574                public TfootContext tfoot(int i) {
8575                        return getRuleContext(TfootContext.class,i);
8576                }
8577                public List<PTagOpenContext> pTagOpen() {
8578                        return getRuleContexts(PTagOpenContext.class);
8579                }
8580                public PTagOpenContext pTagOpen(int i) {
8581                        return getRuleContext(PTagOpenContext.class,i);
8582                }
8583                public List<LiTagOpenContext> liTagOpen() {
8584                        return getRuleContexts(LiTagOpenContext.class);
8585                }
8586                public LiTagOpenContext liTagOpen(int i) {
8587                        return getRuleContext(LiTagOpenContext.class,i);
8588                }
8589                public List<TrTagOpenContext> trTagOpen() {
8590                        return getRuleContexts(TrTagOpenContext.class);
8591                }
8592                public TrTagOpenContext trTagOpen(int i) {
8593                        return getRuleContext(TrTagOpenContext.class,i);
8594                }
8595                public List<TdTagOpenContext> tdTagOpen() {
8596                        return getRuleContexts(TdTagOpenContext.class);
8597                }
8598                public TdTagOpenContext tdTagOpen(int i) {
8599                        return getRuleContext(TdTagOpenContext.class,i);
8600                }
8601                public List<ThTagOpenContext> thTagOpen() {
8602                        return getRuleContexts(ThTagOpenContext.class);
8603                }
8604                public ThTagOpenContext thTagOpen(int i) {
8605                        return getRuleContext(ThTagOpenContext.class,i);
8606                }
8607                public List<BodyTagOpenContext> bodyTagOpen() {
8608                        return getRuleContexts(BodyTagOpenContext.class);
8609                }
8610                public BodyTagOpenContext bodyTagOpen(int i) {
8611                        return getRuleContext(BodyTagOpenContext.class,i);
8612                }
8613                public List<ColgroupTagOpenContext> colgroupTagOpen() {
8614                        return getRuleContexts(ColgroupTagOpenContext.class);
8615                }
8616                public ColgroupTagOpenContext colgroupTagOpen(int i) {
8617                        return getRuleContext(ColgroupTagOpenContext.class,i);
8618                }
8619                public List<DdTagOpenContext> ddTagOpen() {
8620                        return getRuleContexts(DdTagOpenContext.class);
8621                }
8622                public DdTagOpenContext ddTagOpen(int i) {
8623                        return getRuleContext(DdTagOpenContext.class,i);
8624                }
8625                public List<DtTagOpenContext> dtTagOpen() {
8626                        return getRuleContexts(DtTagOpenContext.class);
8627                }
8628                public DtTagOpenContext dtTagOpen(int i) {
8629                        return getRuleContext(DtTagOpenContext.class,i);
8630                }
8631                public List<HeadTagOpenContext> headTagOpen() {
8632                        return getRuleContexts(HeadTagOpenContext.class);
8633                }
8634                public HeadTagOpenContext headTagOpen(int i) {
8635                        return getRuleContext(HeadTagOpenContext.class,i);
8636                }
8637                public List<OptionTagOpenContext> optionTagOpen() {
8638                        return getRuleContexts(OptionTagOpenContext.class);
8639                }
8640                public OptionTagOpenContext optionTagOpen(int i) {
8641                        return getRuleContext(OptionTagOpenContext.class,i);
8642                }
8643                public List<TbodyTagOpenContext> tbodyTagOpen() {
8644                        return getRuleContexts(TbodyTagOpenContext.class);
8645                }
8646                public TbodyTagOpenContext tbodyTagOpen(int i) {
8647                        return getRuleContext(TbodyTagOpenContext.class,i);
8648                }
8649                public List<TheadTagOpenContext> theadTagOpen() {
8650                        return getRuleContexts(TheadTagOpenContext.class);
8651                }
8652                public TheadTagOpenContext theadTagOpen(int i) {
8653                        return getRuleContext(TheadTagOpenContext.class,i);
8654                }
8655                public List<TfootTagOpenContext> tfootTagOpen() {
8656                        return getRuleContexts(TfootTagOpenContext.class);
8657                }
8658                public TfootTagOpenContext tfootTagOpen(int i) {
8659                        return getRuleContext(TfootTagOpenContext.class,i);
8660                }
8661                public List<HtmlCommentContext> htmlComment() {
8662                        return getRuleContexts(HtmlCommentContext.class);
8663                }
8664                public HtmlCommentContext htmlComment(int i) {
8665                        return getRuleContext(HtmlCommentContext.class,i);
8666                }
8667                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
8668                public TerminalNode CDATA(int i) {
8669                        return getToken(JavadocParser.CDATA, i);
8670                }
8671                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8672                public TerminalNode NEWLINE(int i) {
8673                        return getToken(JavadocParser.NEWLINE, i);
8674                }
8675                public List<TextContext> text() {
8676                        return getRuleContexts(TextContext.class);
8677                }
8678                public TextContext text(int i) {
8679                        return getRuleContext(TextContext.class,i);
8680                }
8681                public List<JavadocInlineTagContext> javadocInlineTag() {
8682                        return getRuleContexts(JavadocInlineTagContext.class);
8683                }
8684                public JavadocInlineTagContext javadocInlineTag(int i) {
8685                        return getRuleContext(JavadocInlineTagContext.class,i);
8686                }
8687                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8688                public TerminalNode LEADING_ASTERISK(int i) {
8689                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8690                }
8691                public HtmlContext(ParserRuleContext parent, int invokingState) {
8692                        super(parent, invokingState);
8693                }
8694                @Override public int getRuleIndex() { return RULE_html; }
8695                @Override
8696                public void enterRule(ParseTreeListener listener) {
8697                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this);
8698                }
8699                @Override
8700                public void exitRule(ParseTreeListener listener) {
8701                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this);
8702                }
8703                @Override
8704                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
8705                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this);
8706                        else return visitor.visitChildren(this);
8707                }
8708        }
8709
8710        public final HtmlContext html() throws RecognitionException {
8711                HtmlContext _localctx = new HtmlContext(_ctx, getState());
8712                enterRule(_localctx, 76, RULE_html);
8713                try {
8714                        int _alt;
8715                        enterOuterAlt(_localctx, 1);
8716                        {
8717                        setState(1020);
8718                        htmlTagOpen();
8719                        setState(1060);
8720                        _errHandler.sync(this);
8721                        _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8722                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8723                                if ( _alt==1 ) {
8724                                        {
8725                                        setState(1058);
8726                                        _errHandler.sync(this);
8727                                        switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
8728                                        case 1:
8729                                                {
8730                                                setState(1021);
8731                                                htmlTag();
8732                                                }
8733                                                break;
8734                                        case 2:
8735                                                {
8736                                                setState(1022);
8737                                                singletonTag();
8738                                                }
8739                                                break;
8740                                        case 3:
8741                                                {
8742                                                setState(1023);
8743                                                paragraph();
8744                                                }
8745                                                break;
8746                                        case 4:
8747                                                {
8748                                                setState(1024);
8749                                                li();
8750                                                }
8751                                                break;
8752                                        case 5:
8753                                                {
8754                                                setState(1025);
8755                                                tr();
8756                                                }
8757                                                break;
8758                                        case 6:
8759                                                {
8760                                                setState(1026);
8761                                                td();
8762                                                }
8763                                                break;
8764                                        case 7:
8765                                                {
8766                                                setState(1027);
8767                                                th();
8768                                                }
8769                                                break;
8770                                        case 8:
8771                                                {
8772                                                setState(1028);
8773                                                body();
8774                                                }
8775                                                break;
8776                                        case 9:
8777                                                {
8778                                                setState(1029);
8779                                                colgroup();
8780                                                }
8781                                                break;
8782                                        case 10:
8783                                                {
8784                                                setState(1030);
8785                                                dd();
8786                                                }
8787                                                break;
8788                                        case 11:
8789                                                {
8790                                                setState(1031);
8791                                                dt();
8792                                                }
8793                                                break;
8794                                        case 12:
8795                                                {
8796                                                setState(1032);
8797                                                head();
8798                                                }
8799                                                break;
8800                                        case 13:
8801                                                {
8802                                                setState(1033);
8803                                                option();
8804                                                }
8805                                                break;
8806                                        case 14:
8807                                                {
8808                                                setState(1034);
8809                                                tbody();
8810                                                }
8811                                                break;
8812                                        case 15:
8813                                                {
8814                                                setState(1035);
8815                                                thead();
8816                                                }
8817                                                break;
8818                                        case 16:
8819                                                {
8820                                                setState(1036);
8821                                                tfoot();
8822                                                }
8823                                                break;
8824                                        case 17:
8825                                                {
8826                                                setState(1037);
8827                                                pTagOpen();
8828                                                }
8829                                                break;
8830                                        case 18:
8831                                                {
8832                                                setState(1038);
8833                                                liTagOpen();
8834                                                }
8835                                                break;
8836                                        case 19:
8837                                                {
8838                                                setState(1039);
8839                                                trTagOpen();
8840                                                }
8841                                                break;
8842                                        case 20:
8843                                                {
8844                                                setState(1040);
8845                                                tdTagOpen();
8846                                                }
8847                                                break;
8848                                        case 21:
8849                                                {
8850                                                setState(1041);
8851                                                thTagOpen();
8852                                                }
8853                                                break;
8854                                        case 22:
8855                                                {
8856                                                setState(1042);
8857                                                bodyTagOpen();
8858                                                }
8859                                                break;
8860                                        case 23:
8861                                                {
8862                                                setState(1043);
8863                                                colgroupTagOpen();
8864                                                }
8865                                                break;
8866                                        case 24:
8867                                                {
8868                                                setState(1044);
8869                                                ddTagOpen();
8870                                                }
8871                                                break;
8872                                        case 25:
8873                                                {
8874                                                setState(1045);
8875                                                dtTagOpen();
8876                                                }
8877                                                break;
8878                                        case 26:
8879                                                {
8880                                                setState(1046);
8881                                                headTagOpen();
8882                                                }
8883                                                break;
8884                                        case 27:
8885                                                {
8886                                                setState(1047);
8887                                                optionTagOpen();
8888                                                }
8889                                                break;
8890                                        case 28:
8891                                                {
8892                                                setState(1048);
8893                                                tbodyTagOpen();
8894                                                }
8895                                                break;
8896                                        case 29:
8897                                                {
8898                                                setState(1049);
8899                                                theadTagOpen();
8900                                                }
8901                                                break;
8902                                        case 30:
8903                                                {
8904                                                setState(1050);
8905                                                tfootTagOpen();
8906                                                }
8907                                                break;
8908                                        case 31:
8909                                                {
8910                                                {
8911                                                setState(1051);
8912                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
8913                                                setState(1052);
8914                                                match(LEADING_ASTERISK);
8915                                                }
8916                                                }
8917                                                break;
8918                                        case 32:
8919                                                {
8920                                                setState(1053);
8921                                                htmlComment();
8922                                                }
8923                                                break;
8924                                        case 33:
8925                                                {
8926                                                setState(1054);
8927                                                match(CDATA);
8928                                                }
8929                                                break;
8930                                        case 34:
8931                                                {
8932                                                setState(1055);
8933                                                match(NEWLINE);
8934                                                }
8935                                                break;
8936                                        case 35:
8937                                                {
8938                                                setState(1056);
8939                                                text();
8940                                                }
8941                                                break;
8942                                        case 36:
8943                                                {
8944                                                setState(1057);
8945                                                javadocInlineTag();
8946                                                }
8947                                                break;
8948                                        }
8949                                        } 
8950                                }
8951                                setState(1062);
8952                                _errHandler.sync(this);
8953                                _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
8954                        }
8955                        setState(1063);
8956                        htmlTagClose();
8957                        }
8958                }
8959                catch (RecognitionException re) {
8960                        _localctx.exception = re;
8961                        _errHandler.reportError(this, re);
8962                        _errHandler.recover(this, re);
8963                }
8964                finally {
8965                        exitRule();
8966                }
8967                return _localctx;
8968        }
8969
8970        public static class OptionTagOpenContext extends ParserRuleContext {
8971                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
8972                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
8973                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
8974                public List<AttributeContext> attribute() {
8975                        return getRuleContexts(AttributeContext.class);
8976                }
8977                public AttributeContext attribute(int i) {
8978                        return getRuleContext(AttributeContext.class,i);
8979                }
8980                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
8981                public TerminalNode NEWLINE(int i) {
8982                        return getToken(JavadocParser.NEWLINE, i);
8983                }
8984                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
8985                public TerminalNode LEADING_ASTERISK(int i) {
8986                        return getToken(JavadocParser.LEADING_ASTERISK, i);
8987                }
8988                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
8989                public TerminalNode WS(int i) {
8990                        return getToken(JavadocParser.WS, i);
8991                }
8992                public OptionTagOpenContext(ParserRuleContext parent, int invokingState) {
8993                        super(parent, invokingState);
8994                }
8995                @Override public int getRuleIndex() { return RULE_optionTagOpen; }
8996                @Override
8997                public void enterRule(ParseTreeListener listener) {
8998                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this);
8999                }
9000                @Override
9001                public void exitRule(ParseTreeListener listener) {
9002                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this);
9003                }
9004                @Override
9005                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9006                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this);
9007                        else return visitor.visitChildren(this);
9008                }
9009        }
9010
9011        public final OptionTagOpenContext optionTagOpen() throws RecognitionException {
9012                OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState());
9013                enterRule(_localctx, 78, RULE_optionTagOpen);
9014                int _la;
9015                try {
9016                        enterOuterAlt(_localctx, 1);
9017                        {
9018                        setState(1065);
9019                        match(OPEN);
9020                        setState(1066);
9021                        match(OPTION_HTML_TAG_NAME);
9022                        setState(1073);
9023                        _errHandler.sync(this);
9024                        _la = _input.LA(1);
9025                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9026                                {
9027                                setState(1071);
9028                                switch (_input.LA(1)) {
9029                                case HTML_TAG_NAME:
9030                                        {
9031                                        setState(1067);
9032                                        attribute();
9033                                        }
9034                                        break;
9035                                case NEWLINE:
9036                                        {
9037                                        setState(1068);
9038                                        match(NEWLINE);
9039                                        }
9040                                        break;
9041                                case LEADING_ASTERISK:
9042                                        {
9043                                        setState(1069);
9044                                        match(LEADING_ASTERISK);
9045                                        }
9046                                        break;
9047                                case WS:
9048                                        {
9049                                        setState(1070);
9050                                        match(WS);
9051                                        }
9052                                        break;
9053                                default:
9054                                        throw new NoViableAltException(this);
9055                                }
9056                                }
9057                                setState(1075);
9058                                _errHandler.sync(this);
9059                                _la = _input.LA(1);
9060                        }
9061                        setState(1076);
9062                        match(CLOSE);
9063                        }
9064                }
9065                catch (RecognitionException re) {
9066                        _localctx.exception = re;
9067                        _errHandler.reportError(this, re);
9068                        _errHandler.recover(this, re);
9069                }
9070                finally {
9071                        exitRule();
9072                }
9073                return _localctx;
9074        }
9075
9076        public static class OptionTagCloseContext extends ParserRuleContext {
9077                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9078                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9079                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
9080                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9081                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9082                public TerminalNode NEWLINE(int i) {
9083                        return getToken(JavadocParser.NEWLINE, i);
9084                }
9085                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9086                public TerminalNode LEADING_ASTERISK(int i) {
9087                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9088                }
9089                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9090                public TerminalNode WS(int i) {
9091                        return getToken(JavadocParser.WS, i);
9092                }
9093                public OptionTagCloseContext(ParserRuleContext parent, int invokingState) {
9094                        super(parent, invokingState);
9095                }
9096                @Override public int getRuleIndex() { return RULE_optionTagClose; }
9097                @Override
9098                public void enterRule(ParseTreeListener listener) {
9099                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this);
9100                }
9101                @Override
9102                public void exitRule(ParseTreeListener listener) {
9103                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this);
9104                }
9105                @Override
9106                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9107                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this);
9108                        else return visitor.visitChildren(this);
9109                }
9110        }
9111
9112        public final OptionTagCloseContext optionTagClose() throws RecognitionException {
9113                OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState());
9114                enterRule(_localctx, 80, RULE_optionTagClose);
9115                int _la;
9116                try {
9117                        enterOuterAlt(_localctx, 1);
9118                        {
9119                        setState(1078);
9120                        match(OPEN);
9121                        setState(1079);
9122                        match(SLASH);
9123                        setState(1080);
9124                        match(OPTION_HTML_TAG_NAME);
9125                        setState(1084);
9126                        _errHandler.sync(this);
9127                        _la = _input.LA(1);
9128                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9129                                {
9130                                {
9131                                setState(1081);
9132                                _la = _input.LA(1);
9133                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9134                                _errHandler.recoverInline(this);
9135                                } else {
9136                                        consume();
9137                                }
9138                                }
9139                                }
9140                                setState(1086);
9141                                _errHandler.sync(this);
9142                                _la = _input.LA(1);
9143                        }
9144                        setState(1087);
9145                        match(CLOSE);
9146                        }
9147                }
9148                catch (RecognitionException re) {
9149                        _localctx.exception = re;
9150                        _errHandler.reportError(this, re);
9151                        _errHandler.recover(this, re);
9152                }
9153                finally {
9154                        exitRule();
9155                }
9156                return _localctx;
9157        }
9158
9159        public static class OptionContext extends ParserRuleContext {
9160                public OptionTagOpenContext optionTagOpen() {
9161                        return getRuleContext(OptionTagOpenContext.class,0);
9162                }
9163                public OptionTagCloseContext optionTagClose() {
9164                        return getRuleContext(OptionTagCloseContext.class,0);
9165                }
9166                public List<HtmlTagContext> htmlTag() {
9167                        return getRuleContexts(HtmlTagContext.class);
9168                }
9169                public HtmlTagContext htmlTag(int i) {
9170                        return getRuleContext(HtmlTagContext.class,i);
9171                }
9172                public List<SingletonTagContext> singletonTag() {
9173                        return getRuleContexts(SingletonTagContext.class);
9174                }
9175                public SingletonTagContext singletonTag(int i) {
9176                        return getRuleContext(SingletonTagContext.class,i);
9177                }
9178                public List<ParagraphContext> paragraph() {
9179                        return getRuleContexts(ParagraphContext.class);
9180                }
9181                public ParagraphContext paragraph(int i) {
9182                        return getRuleContext(ParagraphContext.class,i);
9183                }
9184                public List<LiContext> li() {
9185                        return getRuleContexts(LiContext.class);
9186                }
9187                public LiContext li(int i) {
9188                        return getRuleContext(LiContext.class,i);
9189                }
9190                public List<TrContext> tr() {
9191                        return getRuleContexts(TrContext.class);
9192                }
9193                public TrContext tr(int i) {
9194                        return getRuleContext(TrContext.class,i);
9195                }
9196                public List<TdContext> td() {
9197                        return getRuleContexts(TdContext.class);
9198                }
9199                public TdContext td(int i) {
9200                        return getRuleContext(TdContext.class,i);
9201                }
9202                public List<ThContext> th() {
9203                        return getRuleContexts(ThContext.class);
9204                }
9205                public ThContext th(int i) {
9206                        return getRuleContext(ThContext.class,i);
9207                }
9208                public List<BodyContext> body() {
9209                        return getRuleContexts(BodyContext.class);
9210                }
9211                public BodyContext body(int i) {
9212                        return getRuleContext(BodyContext.class,i);
9213                }
9214                public List<ColgroupContext> colgroup() {
9215                        return getRuleContexts(ColgroupContext.class);
9216                }
9217                public ColgroupContext colgroup(int i) {
9218                        return getRuleContext(ColgroupContext.class,i);
9219                }
9220                public List<DdContext> dd() {
9221                        return getRuleContexts(DdContext.class);
9222                }
9223                public DdContext dd(int i) {
9224                        return getRuleContext(DdContext.class,i);
9225                }
9226                public List<DtContext> dt() {
9227                        return getRuleContexts(DtContext.class);
9228                }
9229                public DtContext dt(int i) {
9230                        return getRuleContext(DtContext.class,i);
9231                }
9232                public List<HeadContext> head() {
9233                        return getRuleContexts(HeadContext.class);
9234                }
9235                public HeadContext head(int i) {
9236                        return getRuleContext(HeadContext.class,i);
9237                }
9238                public List<HtmlContext> html() {
9239                        return getRuleContexts(HtmlContext.class);
9240                }
9241                public HtmlContext html(int i) {
9242                        return getRuleContext(HtmlContext.class,i);
9243                }
9244                public List<TbodyContext> tbody() {
9245                        return getRuleContexts(TbodyContext.class);
9246                }
9247                public TbodyContext tbody(int i) {
9248                        return getRuleContext(TbodyContext.class,i);
9249                }
9250                public List<TheadContext> thead() {
9251                        return getRuleContexts(TheadContext.class);
9252                }
9253                public TheadContext thead(int i) {
9254                        return getRuleContext(TheadContext.class,i);
9255                }
9256                public List<TfootContext> tfoot() {
9257                        return getRuleContexts(TfootContext.class);
9258                }
9259                public TfootContext tfoot(int i) {
9260                        return getRuleContext(TfootContext.class,i);
9261                }
9262                public List<PTagOpenContext> pTagOpen() {
9263                        return getRuleContexts(PTagOpenContext.class);
9264                }
9265                public PTagOpenContext pTagOpen(int i) {
9266                        return getRuleContext(PTagOpenContext.class,i);
9267                }
9268                public List<LiTagOpenContext> liTagOpen() {
9269                        return getRuleContexts(LiTagOpenContext.class);
9270                }
9271                public LiTagOpenContext liTagOpen(int i) {
9272                        return getRuleContext(LiTagOpenContext.class,i);
9273                }
9274                public List<TrTagOpenContext> trTagOpen() {
9275                        return getRuleContexts(TrTagOpenContext.class);
9276                }
9277                public TrTagOpenContext trTagOpen(int i) {
9278                        return getRuleContext(TrTagOpenContext.class,i);
9279                }
9280                public List<TdTagOpenContext> tdTagOpen() {
9281                        return getRuleContexts(TdTagOpenContext.class);
9282                }
9283                public TdTagOpenContext tdTagOpen(int i) {
9284                        return getRuleContext(TdTagOpenContext.class,i);
9285                }
9286                public List<ThTagOpenContext> thTagOpen() {
9287                        return getRuleContexts(ThTagOpenContext.class);
9288                }
9289                public ThTagOpenContext thTagOpen(int i) {
9290                        return getRuleContext(ThTagOpenContext.class,i);
9291                }
9292                public List<BodyTagOpenContext> bodyTagOpen() {
9293                        return getRuleContexts(BodyTagOpenContext.class);
9294                }
9295                public BodyTagOpenContext bodyTagOpen(int i) {
9296                        return getRuleContext(BodyTagOpenContext.class,i);
9297                }
9298                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9299                        return getRuleContexts(ColgroupTagOpenContext.class);
9300                }
9301                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9302                        return getRuleContext(ColgroupTagOpenContext.class,i);
9303                }
9304                public List<DdTagOpenContext> ddTagOpen() {
9305                        return getRuleContexts(DdTagOpenContext.class);
9306                }
9307                public DdTagOpenContext ddTagOpen(int i) {
9308                        return getRuleContext(DdTagOpenContext.class,i);
9309                }
9310                public List<DtTagOpenContext> dtTagOpen() {
9311                        return getRuleContexts(DtTagOpenContext.class);
9312                }
9313                public DtTagOpenContext dtTagOpen(int i) {
9314                        return getRuleContext(DtTagOpenContext.class,i);
9315                }
9316                public List<HeadTagOpenContext> headTagOpen() {
9317                        return getRuleContexts(HeadTagOpenContext.class);
9318                }
9319                public HeadTagOpenContext headTagOpen(int i) {
9320                        return getRuleContext(HeadTagOpenContext.class,i);
9321                }
9322                public List<HtmlTagOpenContext> htmlTagOpen() {
9323                        return getRuleContexts(HtmlTagOpenContext.class);
9324                }
9325                public HtmlTagOpenContext htmlTagOpen(int i) {
9326                        return getRuleContext(HtmlTagOpenContext.class,i);
9327                }
9328                public List<TbodyTagOpenContext> tbodyTagOpen() {
9329                        return getRuleContexts(TbodyTagOpenContext.class);
9330                }
9331                public TbodyTagOpenContext tbodyTagOpen(int i) {
9332                        return getRuleContext(TbodyTagOpenContext.class,i);
9333                }
9334                public List<TheadTagOpenContext> theadTagOpen() {
9335                        return getRuleContexts(TheadTagOpenContext.class);
9336                }
9337                public TheadTagOpenContext theadTagOpen(int i) {
9338                        return getRuleContext(TheadTagOpenContext.class,i);
9339                }
9340                public List<TfootTagOpenContext> tfootTagOpen() {
9341                        return getRuleContexts(TfootTagOpenContext.class);
9342                }
9343                public TfootTagOpenContext tfootTagOpen(int i) {
9344                        return getRuleContext(TfootTagOpenContext.class,i);
9345                }
9346                public List<HtmlCommentContext> htmlComment() {
9347                        return getRuleContexts(HtmlCommentContext.class);
9348                }
9349                public HtmlCommentContext htmlComment(int i) {
9350                        return getRuleContext(HtmlCommentContext.class,i);
9351                }
9352                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
9353                public TerminalNode CDATA(int i) {
9354                        return getToken(JavadocParser.CDATA, i);
9355                }
9356                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9357                public TerminalNode NEWLINE(int i) {
9358                        return getToken(JavadocParser.NEWLINE, i);
9359                }
9360                public List<TextContext> text() {
9361                        return getRuleContexts(TextContext.class);
9362                }
9363                public TextContext text(int i) {
9364                        return getRuleContext(TextContext.class,i);
9365                }
9366                public List<JavadocInlineTagContext> javadocInlineTag() {
9367                        return getRuleContexts(JavadocInlineTagContext.class);
9368                }
9369                public JavadocInlineTagContext javadocInlineTag(int i) {
9370                        return getRuleContext(JavadocInlineTagContext.class,i);
9371                }
9372                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9373                public TerminalNode LEADING_ASTERISK(int i) {
9374                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9375                }
9376                public OptionContext(ParserRuleContext parent, int invokingState) {
9377                        super(parent, invokingState);
9378                }
9379                @Override public int getRuleIndex() { return RULE_option; }
9380                @Override
9381                public void enterRule(ParseTreeListener listener) {
9382                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this);
9383                }
9384                @Override
9385                public void exitRule(ParseTreeListener listener) {
9386                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this);
9387                }
9388                @Override
9389                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9390                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this);
9391                        else return visitor.visitChildren(this);
9392                }
9393        }
9394
9395        public final OptionContext option() throws RecognitionException {
9396                OptionContext _localctx = new OptionContext(_ctx, getState());
9397                enterRule(_localctx, 82, RULE_option);
9398                try {
9399                        int _alt;
9400                        enterOuterAlt(_localctx, 1);
9401                        {
9402                        setState(1089);
9403                        optionTagOpen();
9404                        setState(1129);
9405                        _errHandler.sync(this);
9406                        _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9407                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9408                                if ( _alt==1 ) {
9409                                        {
9410                                        setState(1127);
9411                                        _errHandler.sync(this);
9412                                        switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
9413                                        case 1:
9414                                                {
9415                                                setState(1090);
9416                                                htmlTag();
9417                                                }
9418                                                break;
9419                                        case 2:
9420                                                {
9421                                                setState(1091);
9422                                                singletonTag();
9423                                                }
9424                                                break;
9425                                        case 3:
9426                                                {
9427                                                setState(1092);
9428                                                paragraph();
9429                                                }
9430                                                break;
9431                                        case 4:
9432                                                {
9433                                                setState(1093);
9434                                                li();
9435                                                }
9436                                                break;
9437                                        case 5:
9438                                                {
9439                                                setState(1094);
9440                                                tr();
9441                                                }
9442                                                break;
9443                                        case 6:
9444                                                {
9445                                                setState(1095);
9446                                                td();
9447                                                }
9448                                                break;
9449                                        case 7:
9450                                                {
9451                                                setState(1096);
9452                                                th();
9453                                                }
9454                                                break;
9455                                        case 8:
9456                                                {
9457                                                setState(1097);
9458                                                body();
9459                                                }
9460                                                break;
9461                                        case 9:
9462                                                {
9463                                                setState(1098);
9464                                                colgroup();
9465                                                }
9466                                                break;
9467                                        case 10:
9468                                                {
9469                                                setState(1099);
9470                                                dd();
9471                                                }
9472                                                break;
9473                                        case 11:
9474                                                {
9475                                                setState(1100);
9476                                                dt();
9477                                                }
9478                                                break;
9479                                        case 12:
9480                                                {
9481                                                setState(1101);
9482                                                head();
9483                                                }
9484                                                break;
9485                                        case 13:
9486                                                {
9487                                                setState(1102);
9488                                                html();
9489                                                }
9490                                                break;
9491                                        case 14:
9492                                                {
9493                                                setState(1103);
9494                                                tbody();
9495                                                }
9496                                                break;
9497                                        case 15:
9498                                                {
9499                                                setState(1104);
9500                                                thead();
9501                                                }
9502                                                break;
9503                                        case 16:
9504                                                {
9505                                                setState(1105);
9506                                                tfoot();
9507                                                }
9508                                                break;
9509                                        case 17:
9510                                                {
9511                                                setState(1106);
9512                                                pTagOpen();
9513                                                }
9514                                                break;
9515                                        case 18:
9516                                                {
9517                                                setState(1107);
9518                                                liTagOpen();
9519                                                }
9520                                                break;
9521                                        case 19:
9522                                                {
9523                                                setState(1108);
9524                                                trTagOpen();
9525                                                }
9526                                                break;
9527                                        case 20:
9528                                                {
9529                                                setState(1109);
9530                                                tdTagOpen();
9531                                                }
9532                                                break;
9533                                        case 21:
9534                                                {
9535                                                setState(1110);
9536                                                thTagOpen();
9537                                                }
9538                                                break;
9539                                        case 22:
9540                                                {
9541                                                setState(1111);
9542                                                bodyTagOpen();
9543                                                }
9544                                                break;
9545                                        case 23:
9546                                                {
9547                                                setState(1112);
9548                                                colgroupTagOpen();
9549                                                }
9550                                                break;
9551                                        case 24:
9552                                                {
9553                                                setState(1113);
9554                                                ddTagOpen();
9555                                                }
9556                                                break;
9557                                        case 25:
9558                                                {
9559                                                setState(1114);
9560                                                dtTagOpen();
9561                                                }
9562                                                break;
9563                                        case 26:
9564                                                {
9565                                                setState(1115);
9566                                                headTagOpen();
9567                                                }
9568                                                break;
9569                                        case 27:
9570                                                {
9571                                                setState(1116);
9572                                                htmlTagOpen();
9573                                                }
9574                                                break;
9575                                        case 28:
9576                                                {
9577                                                setState(1117);
9578                                                tbodyTagOpen();
9579                                                }
9580                                                break;
9581                                        case 29:
9582                                                {
9583                                                setState(1118);
9584                                                theadTagOpen();
9585                                                }
9586                                                break;
9587                                        case 30:
9588                                                {
9589                                                setState(1119);
9590                                                tfootTagOpen();
9591                                                }
9592                                                break;
9593                                        case 31:
9594                                                {
9595                                                {
9596                                                setState(1120);
9597                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
9598                                                setState(1121);
9599                                                match(LEADING_ASTERISK);
9600                                                }
9601                                                }
9602                                                break;
9603                                        case 32:
9604                                                {
9605                                                setState(1122);
9606                                                htmlComment();
9607                                                }
9608                                                break;
9609                                        case 33:
9610                                                {
9611                                                setState(1123);
9612                                                match(CDATA);
9613                                                }
9614                                                break;
9615                                        case 34:
9616                                                {
9617                                                setState(1124);
9618                                                match(NEWLINE);
9619                                                }
9620                                                break;
9621                                        case 35:
9622                                                {
9623                                                setState(1125);
9624                                                text();
9625                                                }
9626                                                break;
9627                                        case 36:
9628                                                {
9629                                                setState(1126);
9630                                                javadocInlineTag();
9631                                                }
9632                                                break;
9633                                        }
9634                                        } 
9635                                }
9636                                setState(1131);
9637                                _errHandler.sync(this);
9638                                _alt = getInterpreter().adaptivePredict(_input,76,_ctx);
9639                        }
9640                        setState(1132);
9641                        optionTagClose();
9642                        }
9643                }
9644                catch (RecognitionException re) {
9645                        _localctx.exception = re;
9646                        _errHandler.reportError(this, re);
9647                        _errHandler.recover(this, re);
9648                }
9649                finally {
9650                        exitRule();
9651                }
9652                return _localctx;
9653        }
9654
9655        public static class TbodyTagOpenContext extends ParserRuleContext {
9656                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9657                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9658                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9659                public List<AttributeContext> attribute() {
9660                        return getRuleContexts(AttributeContext.class);
9661                }
9662                public AttributeContext attribute(int i) {
9663                        return getRuleContext(AttributeContext.class,i);
9664                }
9665                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9666                public TerminalNode NEWLINE(int i) {
9667                        return getToken(JavadocParser.NEWLINE, i);
9668                }
9669                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9670                public TerminalNode LEADING_ASTERISK(int i) {
9671                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9672                }
9673                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9674                public TerminalNode WS(int i) {
9675                        return getToken(JavadocParser.WS, i);
9676                }
9677                public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) {
9678                        super(parent, invokingState);
9679                }
9680                @Override public int getRuleIndex() { return RULE_tbodyTagOpen; }
9681                @Override
9682                public void enterRule(ParseTreeListener listener) {
9683                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this);
9684                }
9685                @Override
9686                public void exitRule(ParseTreeListener listener) {
9687                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this);
9688                }
9689                @Override
9690                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9691                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this);
9692                        else return visitor.visitChildren(this);
9693                }
9694        }
9695
9696        public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException {
9697                TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState());
9698                enterRule(_localctx, 84, RULE_tbodyTagOpen);
9699                int _la;
9700                try {
9701                        enterOuterAlt(_localctx, 1);
9702                        {
9703                        setState(1134);
9704                        match(OPEN);
9705                        setState(1135);
9706                        match(TBODY_HTML_TAG_NAME);
9707                        setState(1142);
9708                        _errHandler.sync(this);
9709                        _la = _input.LA(1);
9710                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
9711                                {
9712                                setState(1140);
9713                                switch (_input.LA(1)) {
9714                                case HTML_TAG_NAME:
9715                                        {
9716                                        setState(1136);
9717                                        attribute();
9718                                        }
9719                                        break;
9720                                case NEWLINE:
9721                                        {
9722                                        setState(1137);
9723                                        match(NEWLINE);
9724                                        }
9725                                        break;
9726                                case LEADING_ASTERISK:
9727                                        {
9728                                        setState(1138);
9729                                        match(LEADING_ASTERISK);
9730                                        }
9731                                        break;
9732                                case WS:
9733                                        {
9734                                        setState(1139);
9735                                        match(WS);
9736                                        }
9737                                        break;
9738                                default:
9739                                        throw new NoViableAltException(this);
9740                                }
9741                                }
9742                                setState(1144);
9743                                _errHandler.sync(this);
9744                                _la = _input.LA(1);
9745                        }
9746                        setState(1145);
9747                        match(CLOSE);
9748                        }
9749                }
9750                catch (RecognitionException re) {
9751                        _localctx.exception = re;
9752                        _errHandler.reportError(this, re);
9753                        _errHandler.recover(this, re);
9754                }
9755                finally {
9756                        exitRule();
9757                }
9758                return _localctx;
9759        }
9760
9761        public static class TbodyTagCloseContext extends ParserRuleContext {
9762                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
9763                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
9764                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
9765                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
9766                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
9767                public TerminalNode NEWLINE(int i) {
9768                        return getToken(JavadocParser.NEWLINE, i);
9769                }
9770                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
9771                public TerminalNode LEADING_ASTERISK(int i) {
9772                        return getToken(JavadocParser.LEADING_ASTERISK, i);
9773                }
9774                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
9775                public TerminalNode WS(int i) {
9776                        return getToken(JavadocParser.WS, i);
9777                }
9778                public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) {
9779                        super(parent, invokingState);
9780                }
9781                @Override public int getRuleIndex() { return RULE_tbodyTagClose; }
9782                @Override
9783                public void enterRule(ParseTreeListener listener) {
9784                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this);
9785                }
9786                @Override
9787                public void exitRule(ParseTreeListener listener) {
9788                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this);
9789                }
9790                @Override
9791                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
9792                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this);
9793                        else return visitor.visitChildren(this);
9794                }
9795        }
9796
9797        public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException {
9798                TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState());
9799                enterRule(_localctx, 86, RULE_tbodyTagClose);
9800                int _la;
9801                try {
9802                        enterOuterAlt(_localctx, 1);
9803                        {
9804                        setState(1147);
9805                        match(OPEN);
9806                        setState(1148);
9807                        match(SLASH);
9808                        setState(1149);
9809                        match(TBODY_HTML_TAG_NAME);
9810                        setState(1153);
9811                        _errHandler.sync(this);
9812                        _la = _input.LA(1);
9813                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
9814                                {
9815                                {
9816                                setState(1150);
9817                                _la = _input.LA(1);
9818                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
9819                                _errHandler.recoverInline(this);
9820                                } else {
9821                                        consume();
9822                                }
9823                                }
9824                                }
9825                                setState(1155);
9826                                _errHandler.sync(this);
9827                                _la = _input.LA(1);
9828                        }
9829                        setState(1156);
9830                        match(CLOSE);
9831                        }
9832                }
9833                catch (RecognitionException re) {
9834                        _localctx.exception = re;
9835                        _errHandler.reportError(this, re);
9836                        _errHandler.recover(this, re);
9837                }
9838                finally {
9839                        exitRule();
9840                }
9841                return _localctx;
9842        }
9843
9844        public static class TbodyContext extends ParserRuleContext {
9845                public TbodyTagOpenContext tbodyTagOpen() {
9846                        return getRuleContext(TbodyTagOpenContext.class,0);
9847                }
9848                public TbodyTagCloseContext tbodyTagClose() {
9849                        return getRuleContext(TbodyTagCloseContext.class,0);
9850                }
9851                public List<HtmlTagContext> htmlTag() {
9852                        return getRuleContexts(HtmlTagContext.class);
9853                }
9854                public HtmlTagContext htmlTag(int i) {
9855                        return getRuleContext(HtmlTagContext.class,i);
9856                }
9857                public List<SingletonTagContext> singletonTag() {
9858                        return getRuleContexts(SingletonTagContext.class);
9859                }
9860                public SingletonTagContext singletonTag(int i) {
9861                        return getRuleContext(SingletonTagContext.class,i);
9862                }
9863                public List<ParagraphContext> paragraph() {
9864                        return getRuleContexts(ParagraphContext.class);
9865                }
9866                public ParagraphContext paragraph(int i) {
9867                        return getRuleContext(ParagraphContext.class,i);
9868                }
9869                public List<LiContext> li() {
9870                        return getRuleContexts(LiContext.class);
9871                }
9872                public LiContext li(int i) {
9873                        return getRuleContext(LiContext.class,i);
9874                }
9875                public List<TrContext> tr() {
9876                        return getRuleContexts(TrContext.class);
9877                }
9878                public TrContext tr(int i) {
9879                        return getRuleContext(TrContext.class,i);
9880                }
9881                public List<TdContext> td() {
9882                        return getRuleContexts(TdContext.class);
9883                }
9884                public TdContext td(int i) {
9885                        return getRuleContext(TdContext.class,i);
9886                }
9887                public List<ThContext> th() {
9888                        return getRuleContexts(ThContext.class);
9889                }
9890                public ThContext th(int i) {
9891                        return getRuleContext(ThContext.class,i);
9892                }
9893                public List<BodyContext> body() {
9894                        return getRuleContexts(BodyContext.class);
9895                }
9896                public BodyContext body(int i) {
9897                        return getRuleContext(BodyContext.class,i);
9898                }
9899                public List<ColgroupContext> colgroup() {
9900                        return getRuleContexts(ColgroupContext.class);
9901                }
9902                public ColgroupContext colgroup(int i) {
9903                        return getRuleContext(ColgroupContext.class,i);
9904                }
9905                public List<DdContext> dd() {
9906                        return getRuleContexts(DdContext.class);
9907                }
9908                public DdContext dd(int i) {
9909                        return getRuleContext(DdContext.class,i);
9910                }
9911                public List<DtContext> dt() {
9912                        return getRuleContexts(DtContext.class);
9913                }
9914                public DtContext dt(int i) {
9915                        return getRuleContext(DtContext.class,i);
9916                }
9917                public List<HeadContext> head() {
9918                        return getRuleContexts(HeadContext.class);
9919                }
9920                public HeadContext head(int i) {
9921                        return getRuleContext(HeadContext.class,i);
9922                }
9923                public List<HtmlContext> html() {
9924                        return getRuleContexts(HtmlContext.class);
9925                }
9926                public HtmlContext html(int i) {
9927                        return getRuleContext(HtmlContext.class,i);
9928                }
9929                public List<OptionContext> option() {
9930                        return getRuleContexts(OptionContext.class);
9931                }
9932                public OptionContext option(int i) {
9933                        return getRuleContext(OptionContext.class,i);
9934                }
9935                public List<TheadContext> thead() {
9936                        return getRuleContexts(TheadContext.class);
9937                }
9938                public TheadContext thead(int i) {
9939                        return getRuleContext(TheadContext.class,i);
9940                }
9941                public List<TfootContext> tfoot() {
9942                        return getRuleContexts(TfootContext.class);
9943                }
9944                public TfootContext tfoot(int i) {
9945                        return getRuleContext(TfootContext.class,i);
9946                }
9947                public List<PTagOpenContext> pTagOpen() {
9948                        return getRuleContexts(PTagOpenContext.class);
9949                }
9950                public PTagOpenContext pTagOpen(int i) {
9951                        return getRuleContext(PTagOpenContext.class,i);
9952                }
9953                public List<LiTagOpenContext> liTagOpen() {
9954                        return getRuleContexts(LiTagOpenContext.class);
9955                }
9956                public LiTagOpenContext liTagOpen(int i) {
9957                        return getRuleContext(LiTagOpenContext.class,i);
9958                }
9959                public List<TrTagOpenContext> trTagOpen() {
9960                        return getRuleContexts(TrTagOpenContext.class);
9961                }
9962                public TrTagOpenContext trTagOpen(int i) {
9963                        return getRuleContext(TrTagOpenContext.class,i);
9964                }
9965                public List<TdTagOpenContext> tdTagOpen() {
9966                        return getRuleContexts(TdTagOpenContext.class);
9967                }
9968                public TdTagOpenContext tdTagOpen(int i) {
9969                        return getRuleContext(TdTagOpenContext.class,i);
9970                }
9971                public List<ThTagOpenContext> thTagOpen() {
9972                        return getRuleContexts(ThTagOpenContext.class);
9973                }
9974                public ThTagOpenContext thTagOpen(int i) {
9975                        return getRuleContext(ThTagOpenContext.class,i);
9976                }
9977                public List<BodyTagOpenContext> bodyTagOpen() {
9978                        return getRuleContexts(BodyTagOpenContext.class);
9979                }
9980                public BodyTagOpenContext bodyTagOpen(int i) {
9981                        return getRuleContext(BodyTagOpenContext.class,i);
9982                }
9983                public List<ColgroupTagOpenContext> colgroupTagOpen() {
9984                        return getRuleContexts(ColgroupTagOpenContext.class);
9985                }
9986                public ColgroupTagOpenContext colgroupTagOpen(int i) {
9987                        return getRuleContext(ColgroupTagOpenContext.class,i);
9988                }
9989                public List<DdTagOpenContext> ddTagOpen() {
9990                        return getRuleContexts(DdTagOpenContext.class);
9991                }
9992                public DdTagOpenContext ddTagOpen(int i) {
9993                        return getRuleContext(DdTagOpenContext.class,i);
9994                }
9995                public List<DtTagOpenContext> dtTagOpen() {
9996                        return getRuleContexts(DtTagOpenContext.class);
9997                }
9998                public DtTagOpenContext dtTagOpen(int i) {
9999                        return getRuleContext(DtTagOpenContext.class,i);
10000                }
10001                public List<HeadTagOpenContext> headTagOpen() {
10002                        return getRuleContexts(HeadTagOpenContext.class);
10003                }
10004                public HeadTagOpenContext headTagOpen(int i) {
10005                        return getRuleContext(HeadTagOpenContext.class,i);
10006                }
10007                public List<HtmlTagOpenContext> htmlTagOpen() {
10008                        return getRuleContexts(HtmlTagOpenContext.class);
10009                }
10010                public HtmlTagOpenContext htmlTagOpen(int i) {
10011                        return getRuleContext(HtmlTagOpenContext.class,i);
10012                }
10013                public List<OptionTagOpenContext> optionTagOpen() {
10014                        return getRuleContexts(OptionTagOpenContext.class);
10015                }
10016                public OptionTagOpenContext optionTagOpen(int i) {
10017                        return getRuleContext(OptionTagOpenContext.class,i);
10018                }
10019                public List<TheadTagOpenContext> theadTagOpen() {
10020                        return getRuleContexts(TheadTagOpenContext.class);
10021                }
10022                public TheadTagOpenContext theadTagOpen(int i) {
10023                        return getRuleContext(TheadTagOpenContext.class,i);
10024                }
10025                public List<TfootTagOpenContext> tfootTagOpen() {
10026                        return getRuleContexts(TfootTagOpenContext.class);
10027                }
10028                public TfootTagOpenContext tfootTagOpen(int i) {
10029                        return getRuleContext(TfootTagOpenContext.class,i);
10030                }
10031                public List<HtmlCommentContext> htmlComment() {
10032                        return getRuleContexts(HtmlCommentContext.class);
10033                }
10034                public HtmlCommentContext htmlComment(int i) {
10035                        return getRuleContext(HtmlCommentContext.class,i);
10036                }
10037                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10038                public TerminalNode CDATA(int i) {
10039                        return getToken(JavadocParser.CDATA, i);
10040                }
10041                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10042                public TerminalNode NEWLINE(int i) {
10043                        return getToken(JavadocParser.NEWLINE, i);
10044                }
10045                public List<TextContext> text() {
10046                        return getRuleContexts(TextContext.class);
10047                }
10048                public TextContext text(int i) {
10049                        return getRuleContext(TextContext.class,i);
10050                }
10051                public List<JavadocInlineTagContext> javadocInlineTag() {
10052                        return getRuleContexts(JavadocInlineTagContext.class);
10053                }
10054                public JavadocInlineTagContext javadocInlineTag(int i) {
10055                        return getRuleContext(JavadocInlineTagContext.class,i);
10056                }
10057                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10058                public TerminalNode LEADING_ASTERISK(int i) {
10059                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10060                }
10061                public TbodyContext(ParserRuleContext parent, int invokingState) {
10062                        super(parent, invokingState);
10063                }
10064                @Override public int getRuleIndex() { return RULE_tbody; }
10065                @Override
10066                public void enterRule(ParseTreeListener listener) {
10067                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this);
10068                }
10069                @Override
10070                public void exitRule(ParseTreeListener listener) {
10071                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this);
10072                }
10073                @Override
10074                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10075                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this);
10076                        else return visitor.visitChildren(this);
10077                }
10078        }
10079
10080        public final TbodyContext tbody() throws RecognitionException {
10081                TbodyContext _localctx = new TbodyContext(_ctx, getState());
10082                enterRule(_localctx, 88, RULE_tbody);
10083                try {
10084                        int _alt;
10085                        enterOuterAlt(_localctx, 1);
10086                        {
10087                        setState(1158);
10088                        tbodyTagOpen();
10089                        setState(1198);
10090                        _errHandler.sync(this);
10091                        _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10092                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10093                                if ( _alt==1 ) {
10094                                        {
10095                                        setState(1196);
10096                                        _errHandler.sync(this);
10097                                        switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
10098                                        case 1:
10099                                                {
10100                                                setState(1159);
10101                                                htmlTag();
10102                                                }
10103                                                break;
10104                                        case 2:
10105                                                {
10106                                                setState(1160);
10107                                                singletonTag();
10108                                                }
10109                                                break;
10110                                        case 3:
10111                                                {
10112                                                setState(1161);
10113                                                paragraph();
10114                                                }
10115                                                break;
10116                                        case 4:
10117                                                {
10118                                                setState(1162);
10119                                                li();
10120                                                }
10121                                                break;
10122                                        case 5:
10123                                                {
10124                                                setState(1163);
10125                                                tr();
10126                                                }
10127                                                break;
10128                                        case 6:
10129                                                {
10130                                                setState(1164);
10131                                                td();
10132                                                }
10133                                                break;
10134                                        case 7:
10135                                                {
10136                                                setState(1165);
10137                                                th();
10138                                                }
10139                                                break;
10140                                        case 8:
10141                                                {
10142                                                setState(1166);
10143                                                body();
10144                                                }
10145                                                break;
10146                                        case 9:
10147                                                {
10148                                                setState(1167);
10149                                                colgroup();
10150                                                }
10151                                                break;
10152                                        case 10:
10153                                                {
10154                                                setState(1168);
10155                                                dd();
10156                                                }
10157                                                break;
10158                                        case 11:
10159                                                {
10160                                                setState(1169);
10161                                                dt();
10162                                                }
10163                                                break;
10164                                        case 12:
10165                                                {
10166                                                setState(1170);
10167                                                head();
10168                                                }
10169                                                break;
10170                                        case 13:
10171                                                {
10172                                                setState(1171);
10173                                                html();
10174                                                }
10175                                                break;
10176                                        case 14:
10177                                                {
10178                                                setState(1172);
10179                                                option();
10180                                                }
10181                                                break;
10182                                        case 15:
10183                                                {
10184                                                setState(1173);
10185                                                thead();
10186                                                }
10187                                                break;
10188                                        case 16:
10189                                                {
10190                                                setState(1174);
10191                                                tfoot();
10192                                                }
10193                                                break;
10194                                        case 17:
10195                                                {
10196                                                setState(1175);
10197                                                pTagOpen();
10198                                                }
10199                                                break;
10200                                        case 18:
10201                                                {
10202                                                setState(1176);
10203                                                liTagOpen();
10204                                                }
10205                                                break;
10206                                        case 19:
10207                                                {
10208                                                setState(1177);
10209                                                trTagOpen();
10210                                                }
10211                                                break;
10212                                        case 20:
10213                                                {
10214                                                setState(1178);
10215                                                tdTagOpen();
10216                                                }
10217                                                break;
10218                                        case 21:
10219                                                {
10220                                                setState(1179);
10221                                                thTagOpen();
10222                                                }
10223                                                break;
10224                                        case 22:
10225                                                {
10226                                                setState(1180);
10227                                                bodyTagOpen();
10228                                                }
10229                                                break;
10230                                        case 23:
10231                                                {
10232                                                setState(1181);
10233                                                colgroupTagOpen();
10234                                                }
10235                                                break;
10236                                        case 24:
10237                                                {
10238                                                setState(1182);
10239                                                ddTagOpen();
10240                                                }
10241                                                break;
10242                                        case 25:
10243                                                {
10244                                                setState(1183);
10245                                                dtTagOpen();
10246                                                }
10247                                                break;
10248                                        case 26:
10249                                                {
10250                                                setState(1184);
10251                                                headTagOpen();
10252                                                }
10253                                                break;
10254                                        case 27:
10255                                                {
10256                                                setState(1185);
10257                                                htmlTagOpen();
10258                                                }
10259                                                break;
10260                                        case 28:
10261                                                {
10262                                                setState(1186);
10263                                                optionTagOpen();
10264                                                }
10265                                                break;
10266                                        case 29:
10267                                                {
10268                                                setState(1187);
10269                                                theadTagOpen();
10270                                                }
10271                                                break;
10272                                        case 30:
10273                                                {
10274                                                setState(1188);
10275                                                tfootTagOpen();
10276                                                }
10277                                                break;
10278                                        case 31:
10279                                                {
10280                                                {
10281                                                setState(1189);
10282                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10283                                                setState(1190);
10284                                                match(LEADING_ASTERISK);
10285                                                }
10286                                                }
10287                                                break;
10288                                        case 32:
10289                                                {
10290                                                setState(1191);
10291                                                htmlComment();
10292                                                }
10293                                                break;
10294                                        case 33:
10295                                                {
10296                                                setState(1192);
10297                                                match(CDATA);
10298                                                }
10299                                                break;
10300                                        case 34:
10301                                                {
10302                                                setState(1193);
10303                                                match(NEWLINE);
10304                                                }
10305                                                break;
10306                                        case 35:
10307                                                {
10308                                                setState(1194);
10309                                                text();
10310                                                }
10311                                                break;
10312                                        case 36:
10313                                                {
10314                                                setState(1195);
10315                                                javadocInlineTag();
10316                                                }
10317                                                break;
10318                                        }
10319                                        } 
10320                                }
10321                                setState(1200);
10322                                _errHandler.sync(this);
10323                                _alt = getInterpreter().adaptivePredict(_input,81,_ctx);
10324                        }
10325                        setState(1201);
10326                        tbodyTagClose();
10327                        }
10328                }
10329                catch (RecognitionException re) {
10330                        _localctx.exception = re;
10331                        _errHandler.reportError(this, re);
10332                        _errHandler.recover(this, re);
10333                }
10334                finally {
10335                        exitRule();
10336                }
10337                return _localctx;
10338        }
10339
10340        public static class TfootTagOpenContext extends ParserRuleContext {
10341                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10342                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10343                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10344                public List<AttributeContext> attribute() {
10345                        return getRuleContexts(AttributeContext.class);
10346                }
10347                public AttributeContext attribute(int i) {
10348                        return getRuleContext(AttributeContext.class,i);
10349                }
10350                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10351                public TerminalNode NEWLINE(int i) {
10352                        return getToken(JavadocParser.NEWLINE, i);
10353                }
10354                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10355                public TerminalNode LEADING_ASTERISK(int i) {
10356                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10357                }
10358                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10359                public TerminalNode WS(int i) {
10360                        return getToken(JavadocParser.WS, i);
10361                }
10362                public TfootTagOpenContext(ParserRuleContext parent, int invokingState) {
10363                        super(parent, invokingState);
10364                }
10365                @Override public int getRuleIndex() { return RULE_tfootTagOpen; }
10366                @Override
10367                public void enterRule(ParseTreeListener listener) {
10368                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this);
10369                }
10370                @Override
10371                public void exitRule(ParseTreeListener listener) {
10372                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this);
10373                }
10374                @Override
10375                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10376                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this);
10377                        else return visitor.visitChildren(this);
10378                }
10379        }
10380
10381        public final TfootTagOpenContext tfootTagOpen() throws RecognitionException {
10382                TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState());
10383                enterRule(_localctx, 90, RULE_tfootTagOpen);
10384                int _la;
10385                try {
10386                        enterOuterAlt(_localctx, 1);
10387                        {
10388                        setState(1203);
10389                        match(OPEN);
10390                        setState(1204);
10391                        match(TFOOT_HTML_TAG_NAME);
10392                        setState(1211);
10393                        _errHandler.sync(this);
10394                        _la = _input.LA(1);
10395                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
10396                                {
10397                                setState(1209);
10398                                switch (_input.LA(1)) {
10399                                case HTML_TAG_NAME:
10400                                        {
10401                                        setState(1205);
10402                                        attribute();
10403                                        }
10404                                        break;
10405                                case NEWLINE:
10406                                        {
10407                                        setState(1206);
10408                                        match(NEWLINE);
10409                                        }
10410                                        break;
10411                                case LEADING_ASTERISK:
10412                                        {
10413                                        setState(1207);
10414                                        match(LEADING_ASTERISK);
10415                                        }
10416                                        break;
10417                                case WS:
10418                                        {
10419                                        setState(1208);
10420                                        match(WS);
10421                                        }
10422                                        break;
10423                                default:
10424                                        throw new NoViableAltException(this);
10425                                }
10426                                }
10427                                setState(1213);
10428                                _errHandler.sync(this);
10429                                _la = _input.LA(1);
10430                        }
10431                        setState(1214);
10432                        match(CLOSE);
10433                        }
10434                }
10435                catch (RecognitionException re) {
10436                        _localctx.exception = re;
10437                        _errHandler.reportError(this, re);
10438                        _errHandler.recover(this, re);
10439                }
10440                finally {
10441                        exitRule();
10442                }
10443                return _localctx;
10444        }
10445
10446        public static class TfootTagCloseContext extends ParserRuleContext {
10447                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
10448                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
10449                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
10450                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
10451                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10452                public TerminalNode NEWLINE(int i) {
10453                        return getToken(JavadocParser.NEWLINE, i);
10454                }
10455                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10456                public TerminalNode LEADING_ASTERISK(int i) {
10457                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10458                }
10459                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
10460                public TerminalNode WS(int i) {
10461                        return getToken(JavadocParser.WS, i);
10462                }
10463                public TfootTagCloseContext(ParserRuleContext parent, int invokingState) {
10464                        super(parent, invokingState);
10465                }
10466                @Override public int getRuleIndex() { return RULE_tfootTagClose; }
10467                @Override
10468                public void enterRule(ParseTreeListener listener) {
10469                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this);
10470                }
10471                @Override
10472                public void exitRule(ParseTreeListener listener) {
10473                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this);
10474                }
10475                @Override
10476                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10477                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this);
10478                        else return visitor.visitChildren(this);
10479                }
10480        }
10481
10482        public final TfootTagCloseContext tfootTagClose() throws RecognitionException {
10483                TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState());
10484                enterRule(_localctx, 92, RULE_tfootTagClose);
10485                int _la;
10486                try {
10487                        enterOuterAlt(_localctx, 1);
10488                        {
10489                        setState(1216);
10490                        match(OPEN);
10491                        setState(1217);
10492                        match(SLASH);
10493                        setState(1218);
10494                        match(TFOOT_HTML_TAG_NAME);
10495                        setState(1222);
10496                        _errHandler.sync(this);
10497                        _la = _input.LA(1);
10498                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
10499                                {
10500                                {
10501                                setState(1219);
10502                                _la = _input.LA(1);
10503                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
10504                                _errHandler.recoverInline(this);
10505                                } else {
10506                                        consume();
10507                                }
10508                                }
10509                                }
10510                                setState(1224);
10511                                _errHandler.sync(this);
10512                                _la = _input.LA(1);
10513                        }
10514                        setState(1225);
10515                        match(CLOSE);
10516                        }
10517                }
10518                catch (RecognitionException re) {
10519                        _localctx.exception = re;
10520                        _errHandler.reportError(this, re);
10521                        _errHandler.recover(this, re);
10522                }
10523                finally {
10524                        exitRule();
10525                }
10526                return _localctx;
10527        }
10528
10529        public static class TfootContext extends ParserRuleContext {
10530                public TfootTagOpenContext tfootTagOpen() {
10531                        return getRuleContext(TfootTagOpenContext.class,0);
10532                }
10533                public TfootTagCloseContext tfootTagClose() {
10534                        return getRuleContext(TfootTagCloseContext.class,0);
10535                }
10536                public List<HtmlTagContext> htmlTag() {
10537                        return getRuleContexts(HtmlTagContext.class);
10538                }
10539                public HtmlTagContext htmlTag(int i) {
10540                        return getRuleContext(HtmlTagContext.class,i);
10541                }
10542                public List<SingletonTagContext> singletonTag() {
10543                        return getRuleContexts(SingletonTagContext.class);
10544                }
10545                public SingletonTagContext singletonTag(int i) {
10546                        return getRuleContext(SingletonTagContext.class,i);
10547                }
10548                public List<ParagraphContext> paragraph() {
10549                        return getRuleContexts(ParagraphContext.class);
10550                }
10551                public ParagraphContext paragraph(int i) {
10552                        return getRuleContext(ParagraphContext.class,i);
10553                }
10554                public List<LiContext> li() {
10555                        return getRuleContexts(LiContext.class);
10556                }
10557                public LiContext li(int i) {
10558                        return getRuleContext(LiContext.class,i);
10559                }
10560                public List<TrContext> tr() {
10561                        return getRuleContexts(TrContext.class);
10562                }
10563                public TrContext tr(int i) {
10564                        return getRuleContext(TrContext.class,i);
10565                }
10566                public List<TdContext> td() {
10567                        return getRuleContexts(TdContext.class);
10568                }
10569                public TdContext td(int i) {
10570                        return getRuleContext(TdContext.class,i);
10571                }
10572                public List<ThContext> th() {
10573                        return getRuleContexts(ThContext.class);
10574                }
10575                public ThContext th(int i) {
10576                        return getRuleContext(ThContext.class,i);
10577                }
10578                public List<BodyContext> body() {
10579                        return getRuleContexts(BodyContext.class);
10580                }
10581                public BodyContext body(int i) {
10582                        return getRuleContext(BodyContext.class,i);
10583                }
10584                public List<ColgroupContext> colgroup() {
10585                        return getRuleContexts(ColgroupContext.class);
10586                }
10587                public ColgroupContext colgroup(int i) {
10588                        return getRuleContext(ColgroupContext.class,i);
10589                }
10590                public List<DdContext> dd() {
10591                        return getRuleContexts(DdContext.class);
10592                }
10593                public DdContext dd(int i) {
10594                        return getRuleContext(DdContext.class,i);
10595                }
10596                public List<DtContext> dt() {
10597                        return getRuleContexts(DtContext.class);
10598                }
10599                public DtContext dt(int i) {
10600                        return getRuleContext(DtContext.class,i);
10601                }
10602                public List<HeadContext> head() {
10603                        return getRuleContexts(HeadContext.class);
10604                }
10605                public HeadContext head(int i) {
10606                        return getRuleContext(HeadContext.class,i);
10607                }
10608                public List<HtmlContext> html() {
10609                        return getRuleContexts(HtmlContext.class);
10610                }
10611                public HtmlContext html(int i) {
10612                        return getRuleContext(HtmlContext.class,i);
10613                }
10614                public List<OptionContext> option() {
10615                        return getRuleContexts(OptionContext.class);
10616                }
10617                public OptionContext option(int i) {
10618                        return getRuleContext(OptionContext.class,i);
10619                }
10620                public List<TbodyContext> tbody() {
10621                        return getRuleContexts(TbodyContext.class);
10622                }
10623                public TbodyContext tbody(int i) {
10624                        return getRuleContext(TbodyContext.class,i);
10625                }
10626                public List<TheadContext> thead() {
10627                        return getRuleContexts(TheadContext.class);
10628                }
10629                public TheadContext thead(int i) {
10630                        return getRuleContext(TheadContext.class,i);
10631                }
10632                public List<PTagOpenContext> pTagOpen() {
10633                        return getRuleContexts(PTagOpenContext.class);
10634                }
10635                public PTagOpenContext pTagOpen(int i) {
10636                        return getRuleContext(PTagOpenContext.class,i);
10637                }
10638                public List<LiTagOpenContext> liTagOpen() {
10639                        return getRuleContexts(LiTagOpenContext.class);
10640                }
10641                public LiTagOpenContext liTagOpen(int i) {
10642                        return getRuleContext(LiTagOpenContext.class,i);
10643                }
10644                public List<TrTagOpenContext> trTagOpen() {
10645                        return getRuleContexts(TrTagOpenContext.class);
10646                }
10647                public TrTagOpenContext trTagOpen(int i) {
10648                        return getRuleContext(TrTagOpenContext.class,i);
10649                }
10650                public List<TdTagOpenContext> tdTagOpen() {
10651                        return getRuleContexts(TdTagOpenContext.class);
10652                }
10653                public TdTagOpenContext tdTagOpen(int i) {
10654                        return getRuleContext(TdTagOpenContext.class,i);
10655                }
10656                public List<ThTagOpenContext> thTagOpen() {
10657                        return getRuleContexts(ThTagOpenContext.class);
10658                }
10659                public ThTagOpenContext thTagOpen(int i) {
10660                        return getRuleContext(ThTagOpenContext.class,i);
10661                }
10662                public List<BodyTagOpenContext> bodyTagOpen() {
10663                        return getRuleContexts(BodyTagOpenContext.class);
10664                }
10665                public BodyTagOpenContext bodyTagOpen(int i) {
10666                        return getRuleContext(BodyTagOpenContext.class,i);
10667                }
10668                public List<ColgroupTagOpenContext> colgroupTagOpen() {
10669                        return getRuleContexts(ColgroupTagOpenContext.class);
10670                }
10671                public ColgroupTagOpenContext colgroupTagOpen(int i) {
10672                        return getRuleContext(ColgroupTagOpenContext.class,i);
10673                }
10674                public List<DdTagOpenContext> ddTagOpen() {
10675                        return getRuleContexts(DdTagOpenContext.class);
10676                }
10677                public DdTagOpenContext ddTagOpen(int i) {
10678                        return getRuleContext(DdTagOpenContext.class,i);
10679                }
10680                public List<DtTagOpenContext> dtTagOpen() {
10681                        return getRuleContexts(DtTagOpenContext.class);
10682                }
10683                public DtTagOpenContext dtTagOpen(int i) {
10684                        return getRuleContext(DtTagOpenContext.class,i);
10685                }
10686                public List<HeadTagOpenContext> headTagOpen() {
10687                        return getRuleContexts(HeadTagOpenContext.class);
10688                }
10689                public HeadTagOpenContext headTagOpen(int i) {
10690                        return getRuleContext(HeadTagOpenContext.class,i);
10691                }
10692                public List<HtmlTagOpenContext> htmlTagOpen() {
10693                        return getRuleContexts(HtmlTagOpenContext.class);
10694                }
10695                public HtmlTagOpenContext htmlTagOpen(int i) {
10696                        return getRuleContext(HtmlTagOpenContext.class,i);
10697                }
10698                public List<OptionTagOpenContext> optionTagOpen() {
10699                        return getRuleContexts(OptionTagOpenContext.class);
10700                }
10701                public OptionTagOpenContext optionTagOpen(int i) {
10702                        return getRuleContext(OptionTagOpenContext.class,i);
10703                }
10704                public List<TbodyTagOpenContext> tbodyTagOpen() {
10705                        return getRuleContexts(TbodyTagOpenContext.class);
10706                }
10707                public TbodyTagOpenContext tbodyTagOpen(int i) {
10708                        return getRuleContext(TbodyTagOpenContext.class,i);
10709                }
10710                public List<TheadTagOpenContext> theadTagOpen() {
10711                        return getRuleContexts(TheadTagOpenContext.class);
10712                }
10713                public TheadTagOpenContext theadTagOpen(int i) {
10714                        return getRuleContext(TheadTagOpenContext.class,i);
10715                }
10716                public List<HtmlCommentContext> htmlComment() {
10717                        return getRuleContexts(HtmlCommentContext.class);
10718                }
10719                public HtmlCommentContext htmlComment(int i) {
10720                        return getRuleContext(HtmlCommentContext.class,i);
10721                }
10722                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
10723                public TerminalNode CDATA(int i) {
10724                        return getToken(JavadocParser.CDATA, i);
10725                }
10726                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
10727                public TerminalNode NEWLINE(int i) {
10728                        return getToken(JavadocParser.NEWLINE, i);
10729                }
10730                public List<TextContext> text() {
10731                        return getRuleContexts(TextContext.class);
10732                }
10733                public TextContext text(int i) {
10734                        return getRuleContext(TextContext.class,i);
10735                }
10736                public List<JavadocInlineTagContext> javadocInlineTag() {
10737                        return getRuleContexts(JavadocInlineTagContext.class);
10738                }
10739                public JavadocInlineTagContext javadocInlineTag(int i) {
10740                        return getRuleContext(JavadocInlineTagContext.class,i);
10741                }
10742                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
10743                public TerminalNode LEADING_ASTERISK(int i) {
10744                        return getToken(JavadocParser.LEADING_ASTERISK, i);
10745                }
10746                public TfootContext(ParserRuleContext parent, int invokingState) {
10747                        super(parent, invokingState);
10748                }
10749                @Override public int getRuleIndex() { return RULE_tfoot; }
10750                @Override
10751                public void enterRule(ParseTreeListener listener) {
10752                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this);
10753                }
10754                @Override
10755                public void exitRule(ParseTreeListener listener) {
10756                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this);
10757                }
10758                @Override
10759                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
10760                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this);
10761                        else return visitor.visitChildren(this);
10762                }
10763        }
10764
10765        public final TfootContext tfoot() throws RecognitionException {
10766                TfootContext _localctx = new TfootContext(_ctx, getState());
10767                enterRule(_localctx, 94, RULE_tfoot);
10768                try {
10769                        int _alt;
10770                        enterOuterAlt(_localctx, 1);
10771                        {
10772                        setState(1227);
10773                        tfootTagOpen();
10774                        setState(1267);
10775                        _errHandler.sync(this);
10776                        _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
10777                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10778                                if ( _alt==1 ) {
10779                                        {
10780                                        setState(1265);
10781                                        _errHandler.sync(this);
10782                                        switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
10783                                        case 1:
10784                                                {
10785                                                setState(1228);
10786                                                htmlTag();
10787                                                }
10788                                                break;
10789                                        case 2:
10790                                                {
10791                                                setState(1229);
10792                                                singletonTag();
10793                                                }
10794                                                break;
10795                                        case 3:
10796                                                {
10797                                                setState(1230);
10798                                                paragraph();
10799                                                }
10800                                                break;
10801                                        case 4:
10802                                                {
10803                                                setState(1231);
10804                                                li();
10805                                                }
10806                                                break;
10807                                        case 5:
10808                                                {
10809                                                setState(1232);
10810                                                tr();
10811                                                }
10812                                                break;
10813                                        case 6:
10814                                                {
10815                                                setState(1233);
10816                                                td();
10817                                                }
10818                                                break;
10819                                        case 7:
10820                                                {
10821                                                setState(1234);
10822                                                th();
10823                                                }
10824                                                break;
10825                                        case 8:
10826                                                {
10827                                                setState(1235);
10828                                                body();
10829                                                }
10830                                                break;
10831                                        case 9:
10832                                                {
10833                                                setState(1236);
10834                                                colgroup();
10835                                                }
10836                                                break;
10837                                        case 10:
10838                                                {
10839                                                setState(1237);
10840                                                dd();
10841                                                }
10842                                                break;
10843                                        case 11:
10844                                                {
10845                                                setState(1238);
10846                                                dt();
10847                                                }
10848                                                break;
10849                                        case 12:
10850                                                {
10851                                                setState(1239);
10852                                                head();
10853                                                }
10854                                                break;
10855                                        case 13:
10856                                                {
10857                                                setState(1240);
10858                                                html();
10859                                                }
10860                                                break;
10861                                        case 14:
10862                                                {
10863                                                setState(1241);
10864                                                option();
10865                                                }
10866                                                break;
10867                                        case 15:
10868                                                {
10869                                                setState(1242);
10870                                                tbody();
10871                                                }
10872                                                break;
10873                                        case 16:
10874                                                {
10875                                                setState(1243);
10876                                                thead();
10877                                                }
10878                                                break;
10879                                        case 17:
10880                                                {
10881                                                setState(1244);
10882                                                pTagOpen();
10883                                                }
10884                                                break;
10885                                        case 18:
10886                                                {
10887                                                setState(1245);
10888                                                liTagOpen();
10889                                                }
10890                                                break;
10891                                        case 19:
10892                                                {
10893                                                setState(1246);
10894                                                trTagOpen();
10895                                                }
10896                                                break;
10897                                        case 20:
10898                                                {
10899                                                setState(1247);
10900                                                tdTagOpen();
10901                                                }
10902                                                break;
10903                                        case 21:
10904                                                {
10905                                                setState(1248);
10906                                                thTagOpen();
10907                                                }
10908                                                break;
10909                                        case 22:
10910                                                {
10911                                                setState(1249);
10912                                                bodyTagOpen();
10913                                                }
10914                                                break;
10915                                        case 23:
10916                                                {
10917                                                setState(1250);
10918                                                colgroupTagOpen();
10919                                                }
10920                                                break;
10921                                        case 24:
10922                                                {
10923                                                setState(1251);
10924                                                ddTagOpen();
10925                                                }
10926                                                break;
10927                                        case 25:
10928                                                {
10929                                                setState(1252);
10930                                                dtTagOpen();
10931                                                }
10932                                                break;
10933                                        case 26:
10934                                                {
10935                                                setState(1253);
10936                                                headTagOpen();
10937                                                }
10938                                                break;
10939                                        case 27:
10940                                                {
10941                                                setState(1254);
10942                                                htmlTagOpen();
10943                                                }
10944                                                break;
10945                                        case 28:
10946                                                {
10947                                                setState(1255);
10948                                                optionTagOpen();
10949                                                }
10950                                                break;
10951                                        case 29:
10952                                                {
10953                                                setState(1256);
10954                                                tbodyTagOpen();
10955                                                }
10956                                                break;
10957                                        case 30:
10958                                                {
10959                                                setState(1257);
10960                                                theadTagOpen();
10961                                                }
10962                                                break;
10963                                        case 31:
10964                                                {
10965                                                {
10966                                                setState(1258);
10967                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
10968                                                setState(1259);
10969                                                match(LEADING_ASTERISK);
10970                                                }
10971                                                }
10972                                                break;
10973                                        case 32:
10974                                                {
10975                                                setState(1260);
10976                                                htmlComment();
10977                                                }
10978                                                break;
10979                                        case 33:
10980                                                {
10981                                                setState(1261);
10982                                                match(CDATA);
10983                                                }
10984                                                break;
10985                                        case 34:
10986                                                {
10987                                                setState(1262);
10988                                                match(NEWLINE);
10989                                                }
10990                                                break;
10991                                        case 35:
10992                                                {
10993                                                setState(1263);
10994                                                text();
10995                                                }
10996                                                break;
10997                                        case 36:
10998                                                {
10999                                                setState(1264);
11000                                                javadocInlineTag();
11001                                                }
11002                                                break;
11003                                        }
11004                                        } 
11005                                }
11006                                setState(1269);
11007                                _errHandler.sync(this);
11008                                _alt = getInterpreter().adaptivePredict(_input,86,_ctx);
11009                        }
11010                        setState(1270);
11011                        tfootTagClose();
11012                        }
11013                }
11014                catch (RecognitionException re) {
11015                        _localctx.exception = re;
11016                        _errHandler.reportError(this, re);
11017                        _errHandler.recover(this, re);
11018                }
11019                finally {
11020                        exitRule();
11021                }
11022                return _localctx;
11023        }
11024
11025        public static class TheadTagOpenContext extends ParserRuleContext {
11026                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11027                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11028                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11029                public List<AttributeContext> attribute() {
11030                        return getRuleContexts(AttributeContext.class);
11031                }
11032                public AttributeContext attribute(int i) {
11033                        return getRuleContext(AttributeContext.class,i);
11034                }
11035                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11036                public TerminalNode NEWLINE(int i) {
11037                        return getToken(JavadocParser.NEWLINE, i);
11038                }
11039                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11040                public TerminalNode LEADING_ASTERISK(int i) {
11041                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11042                }
11043                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11044                public TerminalNode WS(int i) {
11045                        return getToken(JavadocParser.WS, i);
11046                }
11047                public TheadTagOpenContext(ParserRuleContext parent, int invokingState) {
11048                        super(parent, invokingState);
11049                }
11050                @Override public int getRuleIndex() { return RULE_theadTagOpen; }
11051                @Override
11052                public void enterRule(ParseTreeListener listener) {
11053                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this);
11054                }
11055                @Override
11056                public void exitRule(ParseTreeListener listener) {
11057                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this);
11058                }
11059                @Override
11060                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11061                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this);
11062                        else return visitor.visitChildren(this);
11063                }
11064        }
11065
11066        public final TheadTagOpenContext theadTagOpen() throws RecognitionException {
11067                TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState());
11068                enterRule(_localctx, 96, RULE_theadTagOpen);
11069                int _la;
11070                try {
11071                        enterOuterAlt(_localctx, 1);
11072                        {
11073                        setState(1272);
11074                        match(OPEN);
11075                        setState(1273);
11076                        match(THEAD_HTML_TAG_NAME);
11077                        setState(1280);
11078                        _errHandler.sync(this);
11079                        _la = _input.LA(1);
11080                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11081                                {
11082                                setState(1278);
11083                                switch (_input.LA(1)) {
11084                                case HTML_TAG_NAME:
11085                                        {
11086                                        setState(1274);
11087                                        attribute();
11088                                        }
11089                                        break;
11090                                case NEWLINE:
11091                                        {
11092                                        setState(1275);
11093                                        match(NEWLINE);
11094                                        }
11095                                        break;
11096                                case LEADING_ASTERISK:
11097                                        {
11098                                        setState(1276);
11099                                        match(LEADING_ASTERISK);
11100                                        }
11101                                        break;
11102                                case WS:
11103                                        {
11104                                        setState(1277);
11105                                        match(WS);
11106                                        }
11107                                        break;
11108                                default:
11109                                        throw new NoViableAltException(this);
11110                                }
11111                                }
11112                                setState(1282);
11113                                _errHandler.sync(this);
11114                                _la = _input.LA(1);
11115                        }
11116                        setState(1283);
11117                        match(CLOSE);
11118                        }
11119                }
11120                catch (RecognitionException re) {
11121                        _localctx.exception = re;
11122                        _errHandler.reportError(this, re);
11123                        _errHandler.recover(this, re);
11124                }
11125                finally {
11126                        exitRule();
11127                }
11128                return _localctx;
11129        }
11130
11131        public static class TheadTagCloseContext extends ParserRuleContext {
11132                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11133                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
11134                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11135                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
11136                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11137                public TerminalNode NEWLINE(int i) {
11138                        return getToken(JavadocParser.NEWLINE, i);
11139                }
11140                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11141                public TerminalNode LEADING_ASTERISK(int i) {
11142                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11143                }
11144                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11145                public TerminalNode WS(int i) {
11146                        return getToken(JavadocParser.WS, i);
11147                }
11148                public TheadTagCloseContext(ParserRuleContext parent, int invokingState) {
11149                        super(parent, invokingState);
11150                }
11151                @Override public int getRuleIndex() { return RULE_theadTagClose; }
11152                @Override
11153                public void enterRule(ParseTreeListener listener) {
11154                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this);
11155                }
11156                @Override
11157                public void exitRule(ParseTreeListener listener) {
11158                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this);
11159                }
11160                @Override
11161                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11162                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this);
11163                        else return visitor.visitChildren(this);
11164                }
11165        }
11166
11167        public final TheadTagCloseContext theadTagClose() throws RecognitionException {
11168                TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState());
11169                enterRule(_localctx, 98, RULE_theadTagClose);
11170                int _la;
11171                try {
11172                        enterOuterAlt(_localctx, 1);
11173                        {
11174                        setState(1285);
11175                        match(OPEN);
11176                        setState(1286);
11177                        match(SLASH);
11178                        setState(1287);
11179                        match(THEAD_HTML_TAG_NAME);
11180                        setState(1291);
11181                        _errHandler.sync(this);
11182                        _la = _input.LA(1);
11183                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
11184                                {
11185                                {
11186                                setState(1288);
11187                                _la = _input.LA(1);
11188                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
11189                                _errHandler.recoverInline(this);
11190                                } else {
11191                                        consume();
11192                                }
11193                                }
11194                                }
11195                                setState(1293);
11196                                _errHandler.sync(this);
11197                                _la = _input.LA(1);
11198                        }
11199                        setState(1294);
11200                        match(CLOSE);
11201                        }
11202                }
11203                catch (RecognitionException re) {
11204                        _localctx.exception = re;
11205                        _errHandler.reportError(this, re);
11206                        _errHandler.recover(this, re);
11207                }
11208                finally {
11209                        exitRule();
11210                }
11211                return _localctx;
11212        }
11213
11214        public static class TheadContext extends ParserRuleContext {
11215                public TheadTagOpenContext theadTagOpen() {
11216                        return getRuleContext(TheadTagOpenContext.class,0);
11217                }
11218                public TheadTagCloseContext theadTagClose() {
11219                        return getRuleContext(TheadTagCloseContext.class,0);
11220                }
11221                public List<HtmlTagContext> htmlTag() {
11222                        return getRuleContexts(HtmlTagContext.class);
11223                }
11224                public HtmlTagContext htmlTag(int i) {
11225                        return getRuleContext(HtmlTagContext.class,i);
11226                }
11227                public List<SingletonTagContext> singletonTag() {
11228                        return getRuleContexts(SingletonTagContext.class);
11229                }
11230                public SingletonTagContext singletonTag(int i) {
11231                        return getRuleContext(SingletonTagContext.class,i);
11232                }
11233                public List<ParagraphContext> paragraph() {
11234                        return getRuleContexts(ParagraphContext.class);
11235                }
11236                public ParagraphContext paragraph(int i) {
11237                        return getRuleContext(ParagraphContext.class,i);
11238                }
11239                public List<LiContext> li() {
11240                        return getRuleContexts(LiContext.class);
11241                }
11242                public LiContext li(int i) {
11243                        return getRuleContext(LiContext.class,i);
11244                }
11245                public List<TrContext> tr() {
11246                        return getRuleContexts(TrContext.class);
11247                }
11248                public TrContext tr(int i) {
11249                        return getRuleContext(TrContext.class,i);
11250                }
11251                public List<TdContext> td() {
11252                        return getRuleContexts(TdContext.class);
11253                }
11254                public TdContext td(int i) {
11255                        return getRuleContext(TdContext.class,i);
11256                }
11257                public List<ThContext> th() {
11258                        return getRuleContexts(ThContext.class);
11259                }
11260                public ThContext th(int i) {
11261                        return getRuleContext(ThContext.class,i);
11262                }
11263                public List<BodyContext> body() {
11264                        return getRuleContexts(BodyContext.class);
11265                }
11266                public BodyContext body(int i) {
11267                        return getRuleContext(BodyContext.class,i);
11268                }
11269                public List<ColgroupContext> colgroup() {
11270                        return getRuleContexts(ColgroupContext.class);
11271                }
11272                public ColgroupContext colgroup(int i) {
11273                        return getRuleContext(ColgroupContext.class,i);
11274                }
11275                public List<DdContext> dd() {
11276                        return getRuleContexts(DdContext.class);
11277                }
11278                public DdContext dd(int i) {
11279                        return getRuleContext(DdContext.class,i);
11280                }
11281                public List<DtContext> dt() {
11282                        return getRuleContexts(DtContext.class);
11283                }
11284                public DtContext dt(int i) {
11285                        return getRuleContext(DtContext.class,i);
11286                }
11287                public List<HeadContext> head() {
11288                        return getRuleContexts(HeadContext.class);
11289                }
11290                public HeadContext head(int i) {
11291                        return getRuleContext(HeadContext.class,i);
11292                }
11293                public List<HtmlContext> html() {
11294                        return getRuleContexts(HtmlContext.class);
11295                }
11296                public HtmlContext html(int i) {
11297                        return getRuleContext(HtmlContext.class,i);
11298                }
11299                public List<OptionContext> option() {
11300                        return getRuleContexts(OptionContext.class);
11301                }
11302                public OptionContext option(int i) {
11303                        return getRuleContext(OptionContext.class,i);
11304                }
11305                public List<TbodyContext> tbody() {
11306                        return getRuleContexts(TbodyContext.class);
11307                }
11308                public TbodyContext tbody(int i) {
11309                        return getRuleContext(TbodyContext.class,i);
11310                }
11311                public List<TfootContext> tfoot() {
11312                        return getRuleContexts(TfootContext.class);
11313                }
11314                public TfootContext tfoot(int i) {
11315                        return getRuleContext(TfootContext.class,i);
11316                }
11317                public List<PTagOpenContext> pTagOpen() {
11318                        return getRuleContexts(PTagOpenContext.class);
11319                }
11320                public PTagOpenContext pTagOpen(int i) {
11321                        return getRuleContext(PTagOpenContext.class,i);
11322                }
11323                public List<LiTagOpenContext> liTagOpen() {
11324                        return getRuleContexts(LiTagOpenContext.class);
11325                }
11326                public LiTagOpenContext liTagOpen(int i) {
11327                        return getRuleContext(LiTagOpenContext.class,i);
11328                }
11329                public List<TrTagOpenContext> trTagOpen() {
11330                        return getRuleContexts(TrTagOpenContext.class);
11331                }
11332                public TrTagOpenContext trTagOpen(int i) {
11333                        return getRuleContext(TrTagOpenContext.class,i);
11334                }
11335                public List<TdTagOpenContext> tdTagOpen() {
11336                        return getRuleContexts(TdTagOpenContext.class);
11337                }
11338                public TdTagOpenContext tdTagOpen(int i) {
11339                        return getRuleContext(TdTagOpenContext.class,i);
11340                }
11341                public List<ThTagOpenContext> thTagOpen() {
11342                        return getRuleContexts(ThTagOpenContext.class);
11343                }
11344                public ThTagOpenContext thTagOpen(int i) {
11345                        return getRuleContext(ThTagOpenContext.class,i);
11346                }
11347                public List<BodyTagOpenContext> bodyTagOpen() {
11348                        return getRuleContexts(BodyTagOpenContext.class);
11349                }
11350                public BodyTagOpenContext bodyTagOpen(int i) {
11351                        return getRuleContext(BodyTagOpenContext.class,i);
11352                }
11353                public List<ColgroupTagOpenContext> colgroupTagOpen() {
11354                        return getRuleContexts(ColgroupTagOpenContext.class);
11355                }
11356                public ColgroupTagOpenContext colgroupTagOpen(int i) {
11357                        return getRuleContext(ColgroupTagOpenContext.class,i);
11358                }
11359                public List<DdTagOpenContext> ddTagOpen() {
11360                        return getRuleContexts(DdTagOpenContext.class);
11361                }
11362                public DdTagOpenContext ddTagOpen(int i) {
11363                        return getRuleContext(DdTagOpenContext.class,i);
11364                }
11365                public List<DtTagOpenContext> dtTagOpen() {
11366                        return getRuleContexts(DtTagOpenContext.class);
11367                }
11368                public DtTagOpenContext dtTagOpen(int i) {
11369                        return getRuleContext(DtTagOpenContext.class,i);
11370                }
11371                public List<HeadTagOpenContext> headTagOpen() {
11372                        return getRuleContexts(HeadTagOpenContext.class);
11373                }
11374                public HeadTagOpenContext headTagOpen(int i) {
11375                        return getRuleContext(HeadTagOpenContext.class,i);
11376                }
11377                public List<HtmlTagOpenContext> htmlTagOpen() {
11378                        return getRuleContexts(HtmlTagOpenContext.class);
11379                }
11380                public HtmlTagOpenContext htmlTagOpen(int i) {
11381                        return getRuleContext(HtmlTagOpenContext.class,i);
11382                }
11383                public List<OptionTagOpenContext> optionTagOpen() {
11384                        return getRuleContexts(OptionTagOpenContext.class);
11385                }
11386                public OptionTagOpenContext optionTagOpen(int i) {
11387                        return getRuleContext(OptionTagOpenContext.class,i);
11388                }
11389                public List<TbodyTagOpenContext> tbodyTagOpen() {
11390                        return getRuleContexts(TbodyTagOpenContext.class);
11391                }
11392                public TbodyTagOpenContext tbodyTagOpen(int i) {
11393                        return getRuleContext(TbodyTagOpenContext.class,i);
11394                }
11395                public List<TfootTagOpenContext> tfootTagOpen() {
11396                        return getRuleContexts(TfootTagOpenContext.class);
11397                }
11398                public TfootTagOpenContext tfootTagOpen(int i) {
11399                        return getRuleContext(TfootTagOpenContext.class,i);
11400                }
11401                public List<HtmlCommentContext> htmlComment() {
11402                        return getRuleContexts(HtmlCommentContext.class);
11403                }
11404                public HtmlCommentContext htmlComment(int i) {
11405                        return getRuleContext(HtmlCommentContext.class,i);
11406                }
11407                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
11408                public TerminalNode CDATA(int i) {
11409                        return getToken(JavadocParser.CDATA, i);
11410                }
11411                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11412                public TerminalNode NEWLINE(int i) {
11413                        return getToken(JavadocParser.NEWLINE, i);
11414                }
11415                public List<TextContext> text() {
11416                        return getRuleContexts(TextContext.class);
11417                }
11418                public TextContext text(int i) {
11419                        return getRuleContext(TextContext.class,i);
11420                }
11421                public List<JavadocInlineTagContext> javadocInlineTag() {
11422                        return getRuleContexts(JavadocInlineTagContext.class);
11423                }
11424                public JavadocInlineTagContext javadocInlineTag(int i) {
11425                        return getRuleContext(JavadocInlineTagContext.class,i);
11426                }
11427                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11428                public TerminalNode LEADING_ASTERISK(int i) {
11429                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11430                }
11431                public TheadContext(ParserRuleContext parent, int invokingState) {
11432                        super(parent, invokingState);
11433                }
11434                @Override public int getRuleIndex() { return RULE_thead; }
11435                @Override
11436                public void enterRule(ParseTreeListener listener) {
11437                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this);
11438                }
11439                @Override
11440                public void exitRule(ParseTreeListener listener) {
11441                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this);
11442                }
11443                @Override
11444                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11445                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this);
11446                        else return visitor.visitChildren(this);
11447                }
11448        }
11449
11450        public final TheadContext thead() throws RecognitionException {
11451                TheadContext _localctx = new TheadContext(_ctx, getState());
11452                enterRule(_localctx, 100, RULE_thead);
11453                try {
11454                        int _alt;
11455                        enterOuterAlt(_localctx, 1);
11456                        {
11457                        setState(1296);
11458                        theadTagOpen();
11459                        setState(1336);
11460                        _errHandler.sync(this);
11461                        _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11462                        while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11463                                if ( _alt==1 ) {
11464                                        {
11465                                        setState(1334);
11466                                        _errHandler.sync(this);
11467                                        switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
11468                                        case 1:
11469                                                {
11470                                                setState(1297);
11471                                                htmlTag();
11472                                                }
11473                                                break;
11474                                        case 2:
11475                                                {
11476                                                setState(1298);
11477                                                singletonTag();
11478                                                }
11479                                                break;
11480                                        case 3:
11481                                                {
11482                                                setState(1299);
11483                                                paragraph();
11484                                                }
11485                                                break;
11486                                        case 4:
11487                                                {
11488                                                setState(1300);
11489                                                li();
11490                                                }
11491                                                break;
11492                                        case 5:
11493                                                {
11494                                                setState(1301);
11495                                                tr();
11496                                                }
11497                                                break;
11498                                        case 6:
11499                                                {
11500                                                setState(1302);
11501                                                td();
11502                                                }
11503                                                break;
11504                                        case 7:
11505                                                {
11506                                                setState(1303);
11507                                                th();
11508                                                }
11509                                                break;
11510                                        case 8:
11511                                                {
11512                                                setState(1304);
11513                                                body();
11514                                                }
11515                                                break;
11516                                        case 9:
11517                                                {
11518                                                setState(1305);
11519                                                colgroup();
11520                                                }
11521                                                break;
11522                                        case 10:
11523                                                {
11524                                                setState(1306);
11525                                                dd();
11526                                                }
11527                                                break;
11528                                        case 11:
11529                                                {
11530                                                setState(1307);
11531                                                dt();
11532                                                }
11533                                                break;
11534                                        case 12:
11535                                                {
11536                                                setState(1308);
11537                                                head();
11538                                                }
11539                                                break;
11540                                        case 13:
11541                                                {
11542                                                setState(1309);
11543                                                html();
11544                                                }
11545                                                break;
11546                                        case 14:
11547                                                {
11548                                                setState(1310);
11549                                                option();
11550                                                }
11551                                                break;
11552                                        case 15:
11553                                                {
11554                                                setState(1311);
11555                                                tbody();
11556                                                }
11557                                                break;
11558                                        case 16:
11559                                                {
11560                                                setState(1312);
11561                                                tfoot();
11562                                                }
11563                                                break;
11564                                        case 17:
11565                                                {
11566                                                setState(1313);
11567                                                pTagOpen();
11568                                                }
11569                                                break;
11570                                        case 18:
11571                                                {
11572                                                setState(1314);
11573                                                liTagOpen();
11574                                                }
11575                                                break;
11576                                        case 19:
11577                                                {
11578                                                setState(1315);
11579                                                trTagOpen();
11580                                                }
11581                                                break;
11582                                        case 20:
11583                                                {
11584                                                setState(1316);
11585                                                tdTagOpen();
11586                                                }
11587                                                break;
11588                                        case 21:
11589                                                {
11590                                                setState(1317);
11591                                                thTagOpen();
11592                                                }
11593                                                break;
11594                                        case 22:
11595                                                {
11596                                                setState(1318);
11597                                                bodyTagOpen();
11598                                                }
11599                                                break;
11600                                        case 23:
11601                                                {
11602                                                setState(1319);
11603                                                colgroupTagOpen();
11604                                                }
11605                                                break;
11606                                        case 24:
11607                                                {
11608                                                setState(1320);
11609                                                ddTagOpen();
11610                                                }
11611                                                break;
11612                                        case 25:
11613                                                {
11614                                                setState(1321);
11615                                                dtTagOpen();
11616                                                }
11617                                                break;
11618                                        case 26:
11619                                                {
11620                                                setState(1322);
11621                                                headTagOpen();
11622                                                }
11623                                                break;
11624                                        case 27:
11625                                                {
11626                                                setState(1323);
11627                                                htmlTagOpen();
11628                                                }
11629                                                break;
11630                                        case 28:
11631                                                {
11632                                                setState(1324);
11633                                                optionTagOpen();
11634                                                }
11635                                                break;
11636                                        case 29:
11637                                                {
11638                                                setState(1325);
11639                                                tbodyTagOpen();
11640                                                }
11641                                                break;
11642                                        case 30:
11643                                                {
11644                                                setState(1326);
11645                                                tfootTagOpen();
11646                                                }
11647                                                break;
11648                                        case 31:
11649                                                {
11650                                                {
11651                                                setState(1327);
11652                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
11653                                                setState(1328);
11654                                                match(LEADING_ASTERISK);
11655                                                }
11656                                                }
11657                                                break;
11658                                        case 32:
11659                                                {
11660                                                setState(1329);
11661                                                htmlComment();
11662                                                }
11663                                                break;
11664                                        case 33:
11665                                                {
11666                                                setState(1330);
11667                                                match(CDATA);
11668                                                }
11669                                                break;
11670                                        case 34:
11671                                                {
11672                                                setState(1331);
11673                                                match(NEWLINE);
11674                                                }
11675                                                break;
11676                                        case 35:
11677                                                {
11678                                                setState(1332);
11679                                                text();
11680                                                }
11681                                                break;
11682                                        case 36:
11683                                                {
11684                                                setState(1333);
11685                                                javadocInlineTag();
11686                                                }
11687                                                break;
11688                                        }
11689                                        } 
11690                                }
11691                                setState(1338);
11692                                _errHandler.sync(this);
11693                                _alt = getInterpreter().adaptivePredict(_input,91,_ctx);
11694                        }
11695                        setState(1339);
11696                        theadTagClose();
11697                        }
11698                }
11699                catch (RecognitionException re) {
11700                        _localctx.exception = re;
11701                        _errHandler.reportError(this, re);
11702                        _errHandler.recover(this, re);
11703                }
11704                finally {
11705                        exitRule();
11706                }
11707                return _localctx;
11708        }
11709
11710        public static class SingletonElementContext extends ParserRuleContext {
11711                public SingletonTagContext singletonTag() {
11712                        return getRuleContext(SingletonTagContext.class,0);
11713                }
11714                public AreaTagContext areaTag() {
11715                        return getRuleContext(AreaTagContext.class,0);
11716                }
11717                public BaseTagContext baseTag() {
11718                        return getRuleContext(BaseTagContext.class,0);
11719                }
11720                public BasefrontTagContext basefrontTag() {
11721                        return getRuleContext(BasefrontTagContext.class,0);
11722                }
11723                public BrTagContext brTag() {
11724                        return getRuleContext(BrTagContext.class,0);
11725                }
11726                public ColTagContext colTag() {
11727                        return getRuleContext(ColTagContext.class,0);
11728                }
11729                public FrameTagContext frameTag() {
11730                        return getRuleContext(FrameTagContext.class,0);
11731                }
11732                public HrTagContext hrTag() {
11733                        return getRuleContext(HrTagContext.class,0);
11734                }
11735                public ImgTagContext imgTag() {
11736                        return getRuleContext(ImgTagContext.class,0);
11737                }
11738                public InputTagContext inputTag() {
11739                        return getRuleContext(InputTagContext.class,0);
11740                }
11741                public IsindexTagContext isindexTag() {
11742                        return getRuleContext(IsindexTagContext.class,0);
11743                }
11744                public LinkTagContext linkTag() {
11745                        return getRuleContext(LinkTagContext.class,0);
11746                }
11747                public MetaTagContext metaTag() {
11748                        return getRuleContext(MetaTagContext.class,0);
11749                }
11750                public ParamTagContext paramTag() {
11751                        return getRuleContext(ParamTagContext.class,0);
11752                }
11753                public WrongSinletonTagContext wrongSinletonTag() {
11754                        return getRuleContext(WrongSinletonTagContext.class,0);
11755                }
11756                public SingletonElementContext(ParserRuleContext parent, int invokingState) {
11757                        super(parent, invokingState);
11758                }
11759                @Override public int getRuleIndex() { return RULE_singletonElement; }
11760                @Override
11761                public void enterRule(ParseTreeListener listener) {
11762                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this);
11763                }
11764                @Override
11765                public void exitRule(ParseTreeListener listener) {
11766                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this);
11767                }
11768                @Override
11769                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11770                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this);
11771                        else return visitor.visitChildren(this);
11772                }
11773        }
11774
11775        public final SingletonElementContext singletonElement() throws RecognitionException {
11776                SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState());
11777                enterRule(_localctx, 102, RULE_singletonElement);
11778                try {
11779                        setState(1356);
11780                        _errHandler.sync(this);
11781                        switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
11782                        case 1:
11783                                enterOuterAlt(_localctx, 1);
11784                                {
11785                                setState(1341);
11786                                singletonTag();
11787                                }
11788                                break;
11789                        case 2:
11790                                enterOuterAlt(_localctx, 2);
11791                                {
11792                                setState(1342);
11793                                areaTag();
11794                                }
11795                                break;
11796                        case 3:
11797                                enterOuterAlt(_localctx, 3);
11798                                {
11799                                setState(1343);
11800                                baseTag();
11801                                }
11802                                break;
11803                        case 4:
11804                                enterOuterAlt(_localctx, 4);
11805                                {
11806                                setState(1344);
11807                                basefrontTag();
11808                                }
11809                                break;
11810                        case 5:
11811                                enterOuterAlt(_localctx, 5);
11812                                {
11813                                setState(1345);
11814                                brTag();
11815                                }
11816                                break;
11817                        case 6:
11818                                enterOuterAlt(_localctx, 6);
11819                                {
11820                                setState(1346);
11821                                colTag();
11822                                }
11823                                break;
11824                        case 7:
11825                                enterOuterAlt(_localctx, 7);
11826                                {
11827                                setState(1347);
11828                                frameTag();
11829                                }
11830                                break;
11831                        case 8:
11832                                enterOuterAlt(_localctx, 8);
11833                                {
11834                                setState(1348);
11835                                hrTag();
11836                                }
11837                                break;
11838                        case 9:
11839                                enterOuterAlt(_localctx, 9);
11840                                {
11841                                setState(1349);
11842                                imgTag();
11843                                }
11844                                break;
11845                        case 10:
11846                                enterOuterAlt(_localctx, 10);
11847                                {
11848                                setState(1350);
11849                                inputTag();
11850                                }
11851                                break;
11852                        case 11:
11853                                enterOuterAlt(_localctx, 11);
11854                                {
11855                                setState(1351);
11856                                isindexTag();
11857                                }
11858                                break;
11859                        case 12:
11860                                enterOuterAlt(_localctx, 12);
11861                                {
11862                                setState(1352);
11863                                linkTag();
11864                                }
11865                                break;
11866                        case 13:
11867                                enterOuterAlt(_localctx, 13);
11868                                {
11869                                setState(1353);
11870                                metaTag();
11871                                }
11872                                break;
11873                        case 14:
11874                                enterOuterAlt(_localctx, 14);
11875                                {
11876                                setState(1354);
11877                                paramTag();
11878                                }
11879                                break;
11880                        case 15:
11881                                enterOuterAlt(_localctx, 15);
11882                                {
11883                                setState(1355);
11884                                wrongSinletonTag();
11885                                }
11886                                break;
11887                        }
11888                }
11889                catch (RecognitionException re) {
11890                        _localctx.exception = re;
11891                        _errHandler.reportError(this, re);
11892                        _errHandler.recover(this, re);
11893                }
11894                finally {
11895                        exitRule();
11896                }
11897                return _localctx;
11898        }
11899
11900        public static class SingletonTagContext extends ParserRuleContext {
11901                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
11902                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
11903                public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); }
11904                public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); }
11905                public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); }
11906                public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); }
11907                public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); }
11908                public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); }
11909                public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); }
11910                public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); }
11911                public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); }
11912                public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); }
11913                public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); }
11914                public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); }
11915                public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); }
11916                public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); }
11917                public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); }
11918                public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); }
11919                public List<AttributeContext> attribute() {
11920                        return getRuleContexts(AttributeContext.class);
11921                }
11922                public AttributeContext attribute(int i) {
11923                        return getRuleContext(AttributeContext.class,i);
11924                }
11925                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
11926                public TerminalNode NEWLINE(int i) {
11927                        return getToken(JavadocParser.NEWLINE, i);
11928                }
11929                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
11930                public TerminalNode LEADING_ASTERISK(int i) {
11931                        return getToken(JavadocParser.LEADING_ASTERISK, i);
11932                }
11933                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
11934                public TerminalNode WS(int i) {
11935                        return getToken(JavadocParser.WS, i);
11936                }
11937                public SingletonTagContext(ParserRuleContext parent, int invokingState) {
11938                        super(parent, invokingState);
11939                }
11940                @Override public int getRuleIndex() { return RULE_singletonTag; }
11941                @Override
11942                public void enterRule(ParseTreeListener listener) {
11943                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this);
11944                }
11945                @Override
11946                public void exitRule(ParseTreeListener listener) {
11947                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this);
11948                }
11949                @Override
11950                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
11951                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this);
11952                        else return visitor.visitChildren(this);
11953                }
11954        }
11955
11956        public final SingletonTagContext singletonTag() throws RecognitionException {
11957                SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState());
11958                enterRule(_localctx, 104, RULE_singletonTag);
11959                int _la;
11960                try {
11961                        enterOuterAlt(_localctx, 1);
11962                        {
11963                        setState(1358);
11964                        match(OPEN);
11965                        setState(1359);
11966                        _la = _input.LA(1);
11967                        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)) ) {
11968                        _errHandler.recoverInline(this);
11969                        } else {
11970                                consume();
11971                        }
11972                        setState(1366);
11973                        _errHandler.sync(this);
11974                        _la = _input.LA(1);
11975                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
11976                                {
11977                                setState(1364);
11978                                switch (_input.LA(1)) {
11979                                case HTML_TAG_NAME:
11980                                        {
11981                                        setState(1360);
11982                                        attribute();
11983                                        }
11984                                        break;
11985                                case NEWLINE:
11986                                        {
11987                                        setState(1361);
11988                                        match(NEWLINE);
11989                                        }
11990                                        break;
11991                                case LEADING_ASTERISK:
11992                                        {
11993                                        setState(1362);
11994                                        match(LEADING_ASTERISK);
11995                                        }
11996                                        break;
11997                                case WS:
11998                                        {
11999                                        setState(1363);
12000                                        match(WS);
12001                                        }
12002                                        break;
12003                                default:
12004                                        throw new NoViableAltException(this);
12005                                }
12006                                }
12007                                setState(1368);
12008                                _errHandler.sync(this);
12009                                _la = _input.LA(1);
12010                        }
12011                        setState(1369);
12012                        match(SLASH_CLOSE);
12013                        }
12014                }
12015                catch (RecognitionException re) {
12016                        _localctx.exception = re;
12017                        _errHandler.reportError(this, re);
12018                        _errHandler.recover(this, re);
12019                }
12020                finally {
12021                        exitRule();
12022                }
12023                return _localctx;
12024        }
12025
12026        public static class AreaTagContext extends ParserRuleContext {
12027                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12028                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
12029                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12030                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12031                public List<AttributeContext> attribute() {
12032                        return getRuleContexts(AttributeContext.class);
12033                }
12034                public AttributeContext attribute(int i) {
12035                        return getRuleContext(AttributeContext.class,i);
12036                }
12037                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12038                public TerminalNode NEWLINE(int i) {
12039                        return getToken(JavadocParser.NEWLINE, i);
12040                }
12041                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12042                public TerminalNode LEADING_ASTERISK(int i) {
12043                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12044                }
12045                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12046                public TerminalNode WS(int i) {
12047                        return getToken(JavadocParser.WS, i);
12048                }
12049                public AreaTagContext(ParserRuleContext parent, int invokingState) {
12050                        super(parent, invokingState);
12051                }
12052                @Override public int getRuleIndex() { return RULE_areaTag; }
12053                @Override
12054                public void enterRule(ParseTreeListener listener) {
12055                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this);
12056                }
12057                @Override
12058                public void exitRule(ParseTreeListener listener) {
12059                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this);
12060                }
12061                @Override
12062                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12063                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this);
12064                        else return visitor.visitChildren(this);
12065                }
12066        }
12067
12068        public final AreaTagContext areaTag() throws RecognitionException {
12069                AreaTagContext _localctx = new AreaTagContext(_ctx, getState());
12070                enterRule(_localctx, 106, RULE_areaTag);
12071                int _la;
12072                try {
12073                        enterOuterAlt(_localctx, 1);
12074                        {
12075                        setState(1371);
12076                        match(OPEN);
12077                        setState(1372);
12078                        match(AREA_HTML_TAG_NAME);
12079                        setState(1379);
12080                        _errHandler.sync(this);
12081                        _la = _input.LA(1);
12082                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12083                                {
12084                                setState(1377);
12085                                switch (_input.LA(1)) {
12086                                case HTML_TAG_NAME:
12087                                        {
12088                                        setState(1373);
12089                                        attribute();
12090                                        }
12091                                        break;
12092                                case NEWLINE:
12093                                        {
12094                                        setState(1374);
12095                                        match(NEWLINE);
12096                                        }
12097                                        break;
12098                                case LEADING_ASTERISK:
12099                                        {
12100                                        setState(1375);
12101                                        match(LEADING_ASTERISK);
12102                                        }
12103                                        break;
12104                                case WS:
12105                                        {
12106                                        setState(1376);
12107                                        match(WS);
12108                                        }
12109                                        break;
12110                                default:
12111                                        throw new NoViableAltException(this);
12112                                }
12113                                }
12114                                setState(1381);
12115                                _errHandler.sync(this);
12116                                _la = _input.LA(1);
12117                        }
12118                        setState(1382);
12119                        _la = _input.LA(1);
12120                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12121                        _errHandler.recoverInline(this);
12122                        } else {
12123                                consume();
12124                        }
12125                        }
12126                }
12127                catch (RecognitionException re) {
12128                        _localctx.exception = re;
12129                        _errHandler.reportError(this, re);
12130                        _errHandler.recover(this, re);
12131                }
12132                finally {
12133                        exitRule();
12134                }
12135                return _localctx;
12136        }
12137
12138        public static class BaseTagContext extends ParserRuleContext {
12139                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12140                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
12141                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12142                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12143                public List<AttributeContext> attribute() {
12144                        return getRuleContexts(AttributeContext.class);
12145                }
12146                public AttributeContext attribute(int i) {
12147                        return getRuleContext(AttributeContext.class,i);
12148                }
12149                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12150                public TerminalNode NEWLINE(int i) {
12151                        return getToken(JavadocParser.NEWLINE, i);
12152                }
12153                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12154                public TerminalNode LEADING_ASTERISK(int i) {
12155                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12156                }
12157                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12158                public TerminalNode WS(int i) {
12159                        return getToken(JavadocParser.WS, i);
12160                }
12161                public BaseTagContext(ParserRuleContext parent, int invokingState) {
12162                        super(parent, invokingState);
12163                }
12164                @Override public int getRuleIndex() { return RULE_baseTag; }
12165                @Override
12166                public void enterRule(ParseTreeListener listener) {
12167                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this);
12168                }
12169                @Override
12170                public void exitRule(ParseTreeListener listener) {
12171                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this);
12172                }
12173                @Override
12174                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12175                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this);
12176                        else return visitor.visitChildren(this);
12177                }
12178        }
12179
12180        public final BaseTagContext baseTag() throws RecognitionException {
12181                BaseTagContext _localctx = new BaseTagContext(_ctx, getState());
12182                enterRule(_localctx, 108, RULE_baseTag);
12183                int _la;
12184                try {
12185                        enterOuterAlt(_localctx, 1);
12186                        {
12187                        setState(1384);
12188                        match(OPEN);
12189                        setState(1385);
12190                        match(BASE_HTML_TAG_NAME);
12191                        setState(1392);
12192                        _errHandler.sync(this);
12193                        _la = _input.LA(1);
12194                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12195                                {
12196                                setState(1390);
12197                                switch (_input.LA(1)) {
12198                                case HTML_TAG_NAME:
12199                                        {
12200                                        setState(1386);
12201                                        attribute();
12202                                        }
12203                                        break;
12204                                case NEWLINE:
12205                                        {
12206                                        setState(1387);
12207                                        match(NEWLINE);
12208                                        }
12209                                        break;
12210                                case LEADING_ASTERISK:
12211                                        {
12212                                        setState(1388);
12213                                        match(LEADING_ASTERISK);
12214                                        }
12215                                        break;
12216                                case WS:
12217                                        {
12218                                        setState(1389);
12219                                        match(WS);
12220                                        }
12221                                        break;
12222                                default:
12223                                        throw new NoViableAltException(this);
12224                                }
12225                                }
12226                                setState(1394);
12227                                _errHandler.sync(this);
12228                                _la = _input.LA(1);
12229                        }
12230                        setState(1395);
12231                        _la = _input.LA(1);
12232                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12233                        _errHandler.recoverInline(this);
12234                        } else {
12235                                consume();
12236                        }
12237                        }
12238                }
12239                catch (RecognitionException re) {
12240                        _localctx.exception = re;
12241                        _errHandler.reportError(this, re);
12242                        _errHandler.recover(this, re);
12243                }
12244                finally {
12245                        exitRule();
12246                }
12247                return _localctx;
12248        }
12249
12250        public static class BasefrontTagContext extends ParserRuleContext {
12251                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12252                public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); }
12253                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12254                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12255                public List<AttributeContext> attribute() {
12256                        return getRuleContexts(AttributeContext.class);
12257                }
12258                public AttributeContext attribute(int i) {
12259                        return getRuleContext(AttributeContext.class,i);
12260                }
12261                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12262                public TerminalNode NEWLINE(int i) {
12263                        return getToken(JavadocParser.NEWLINE, i);
12264                }
12265                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12266                public TerminalNode LEADING_ASTERISK(int i) {
12267                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12268                }
12269                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12270                public TerminalNode WS(int i) {
12271                        return getToken(JavadocParser.WS, i);
12272                }
12273                public BasefrontTagContext(ParserRuleContext parent, int invokingState) {
12274                        super(parent, invokingState);
12275                }
12276                @Override public int getRuleIndex() { return RULE_basefrontTag; }
12277                @Override
12278                public void enterRule(ParseTreeListener listener) {
12279                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefrontTag(this);
12280                }
12281                @Override
12282                public void exitRule(ParseTreeListener listener) {
12283                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefrontTag(this);
12284                }
12285                @Override
12286                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12287                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefrontTag(this);
12288                        else return visitor.visitChildren(this);
12289                }
12290        }
12291
12292        public final BasefrontTagContext basefrontTag() throws RecognitionException {
12293                BasefrontTagContext _localctx = new BasefrontTagContext(_ctx, getState());
12294                enterRule(_localctx, 110, RULE_basefrontTag);
12295                int _la;
12296                try {
12297                        enterOuterAlt(_localctx, 1);
12298                        {
12299                        setState(1397);
12300                        match(OPEN);
12301                        setState(1398);
12302                        match(BASEFRONT_HTML_TAG_NAME);
12303                        setState(1405);
12304                        _errHandler.sync(this);
12305                        _la = _input.LA(1);
12306                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12307                                {
12308                                setState(1403);
12309                                switch (_input.LA(1)) {
12310                                case HTML_TAG_NAME:
12311                                        {
12312                                        setState(1399);
12313                                        attribute();
12314                                        }
12315                                        break;
12316                                case NEWLINE:
12317                                        {
12318                                        setState(1400);
12319                                        match(NEWLINE);
12320                                        }
12321                                        break;
12322                                case LEADING_ASTERISK:
12323                                        {
12324                                        setState(1401);
12325                                        match(LEADING_ASTERISK);
12326                                        }
12327                                        break;
12328                                case WS:
12329                                        {
12330                                        setState(1402);
12331                                        match(WS);
12332                                        }
12333                                        break;
12334                                default:
12335                                        throw new NoViableAltException(this);
12336                                }
12337                                }
12338                                setState(1407);
12339                                _errHandler.sync(this);
12340                                _la = _input.LA(1);
12341                        }
12342                        setState(1408);
12343                        _la = _input.LA(1);
12344                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12345                        _errHandler.recoverInline(this);
12346                        } else {
12347                                consume();
12348                        }
12349                        }
12350                }
12351                catch (RecognitionException re) {
12352                        _localctx.exception = re;
12353                        _errHandler.reportError(this, re);
12354                        _errHandler.recover(this, re);
12355                }
12356                finally {
12357                        exitRule();
12358                }
12359                return _localctx;
12360        }
12361
12362        public static class BrTagContext extends ParserRuleContext {
12363                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12364                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
12365                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12366                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12367                public List<AttributeContext> attribute() {
12368                        return getRuleContexts(AttributeContext.class);
12369                }
12370                public AttributeContext attribute(int i) {
12371                        return getRuleContext(AttributeContext.class,i);
12372                }
12373                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12374                public TerminalNode NEWLINE(int i) {
12375                        return getToken(JavadocParser.NEWLINE, i);
12376                }
12377                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12378                public TerminalNode LEADING_ASTERISK(int i) {
12379                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12380                }
12381                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12382                public TerminalNode WS(int i) {
12383                        return getToken(JavadocParser.WS, i);
12384                }
12385                public BrTagContext(ParserRuleContext parent, int invokingState) {
12386                        super(parent, invokingState);
12387                }
12388                @Override public int getRuleIndex() { return RULE_brTag; }
12389                @Override
12390                public void enterRule(ParseTreeListener listener) {
12391                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this);
12392                }
12393                @Override
12394                public void exitRule(ParseTreeListener listener) {
12395                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this);
12396                }
12397                @Override
12398                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12399                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this);
12400                        else return visitor.visitChildren(this);
12401                }
12402        }
12403
12404        public final BrTagContext brTag() throws RecognitionException {
12405                BrTagContext _localctx = new BrTagContext(_ctx, getState());
12406                enterRule(_localctx, 112, RULE_brTag);
12407                int _la;
12408                try {
12409                        enterOuterAlt(_localctx, 1);
12410                        {
12411                        setState(1410);
12412                        match(OPEN);
12413                        setState(1411);
12414                        match(BR_HTML_TAG_NAME);
12415                        setState(1418);
12416                        _errHandler.sync(this);
12417                        _la = _input.LA(1);
12418                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12419                                {
12420                                setState(1416);
12421                                switch (_input.LA(1)) {
12422                                case HTML_TAG_NAME:
12423                                        {
12424                                        setState(1412);
12425                                        attribute();
12426                                        }
12427                                        break;
12428                                case NEWLINE:
12429                                        {
12430                                        setState(1413);
12431                                        match(NEWLINE);
12432                                        }
12433                                        break;
12434                                case LEADING_ASTERISK:
12435                                        {
12436                                        setState(1414);
12437                                        match(LEADING_ASTERISK);
12438                                        }
12439                                        break;
12440                                case WS:
12441                                        {
12442                                        setState(1415);
12443                                        match(WS);
12444                                        }
12445                                        break;
12446                                default:
12447                                        throw new NoViableAltException(this);
12448                                }
12449                                }
12450                                setState(1420);
12451                                _errHandler.sync(this);
12452                                _la = _input.LA(1);
12453                        }
12454                        setState(1421);
12455                        _la = _input.LA(1);
12456                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12457                        _errHandler.recoverInline(this);
12458                        } else {
12459                                consume();
12460                        }
12461                        }
12462                }
12463                catch (RecognitionException re) {
12464                        _localctx.exception = re;
12465                        _errHandler.reportError(this, re);
12466                        _errHandler.recover(this, re);
12467                }
12468                finally {
12469                        exitRule();
12470                }
12471                return _localctx;
12472        }
12473
12474        public static class ColTagContext extends ParserRuleContext {
12475                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12476                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
12477                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12478                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12479                public List<AttributeContext> attribute() {
12480                        return getRuleContexts(AttributeContext.class);
12481                }
12482                public AttributeContext attribute(int i) {
12483                        return getRuleContext(AttributeContext.class,i);
12484                }
12485                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12486                public TerminalNode NEWLINE(int i) {
12487                        return getToken(JavadocParser.NEWLINE, i);
12488                }
12489                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12490                public TerminalNode LEADING_ASTERISK(int i) {
12491                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12492                }
12493                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12494                public TerminalNode WS(int i) {
12495                        return getToken(JavadocParser.WS, i);
12496                }
12497                public ColTagContext(ParserRuleContext parent, int invokingState) {
12498                        super(parent, invokingState);
12499                }
12500                @Override public int getRuleIndex() { return RULE_colTag; }
12501                @Override
12502                public void enterRule(ParseTreeListener listener) {
12503                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this);
12504                }
12505                @Override
12506                public void exitRule(ParseTreeListener listener) {
12507                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this);
12508                }
12509                @Override
12510                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12511                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this);
12512                        else return visitor.visitChildren(this);
12513                }
12514        }
12515
12516        public final ColTagContext colTag() throws RecognitionException {
12517                ColTagContext _localctx = new ColTagContext(_ctx, getState());
12518                enterRule(_localctx, 114, RULE_colTag);
12519                int _la;
12520                try {
12521                        enterOuterAlt(_localctx, 1);
12522                        {
12523                        setState(1423);
12524                        match(OPEN);
12525                        setState(1424);
12526                        match(COL_HTML_TAG_NAME);
12527                        setState(1431);
12528                        _errHandler.sync(this);
12529                        _la = _input.LA(1);
12530                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12531                                {
12532                                setState(1429);
12533                                switch (_input.LA(1)) {
12534                                case HTML_TAG_NAME:
12535                                        {
12536                                        setState(1425);
12537                                        attribute();
12538                                        }
12539                                        break;
12540                                case NEWLINE:
12541                                        {
12542                                        setState(1426);
12543                                        match(NEWLINE);
12544                                        }
12545                                        break;
12546                                case LEADING_ASTERISK:
12547                                        {
12548                                        setState(1427);
12549                                        match(LEADING_ASTERISK);
12550                                        }
12551                                        break;
12552                                case WS:
12553                                        {
12554                                        setState(1428);
12555                                        match(WS);
12556                                        }
12557                                        break;
12558                                default:
12559                                        throw new NoViableAltException(this);
12560                                }
12561                                }
12562                                setState(1433);
12563                                _errHandler.sync(this);
12564                                _la = _input.LA(1);
12565                        }
12566                        setState(1434);
12567                        _la = _input.LA(1);
12568                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12569                        _errHandler.recoverInline(this);
12570                        } else {
12571                                consume();
12572                        }
12573                        }
12574                }
12575                catch (RecognitionException re) {
12576                        _localctx.exception = re;
12577                        _errHandler.reportError(this, re);
12578                        _errHandler.recover(this, re);
12579                }
12580                finally {
12581                        exitRule();
12582                }
12583                return _localctx;
12584        }
12585
12586        public static class FrameTagContext extends ParserRuleContext {
12587                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12588                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
12589                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12590                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12591                public List<AttributeContext> attribute() {
12592                        return getRuleContexts(AttributeContext.class);
12593                }
12594                public AttributeContext attribute(int i) {
12595                        return getRuleContext(AttributeContext.class,i);
12596                }
12597                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12598                public TerminalNode NEWLINE(int i) {
12599                        return getToken(JavadocParser.NEWLINE, i);
12600                }
12601                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12602                public TerminalNode LEADING_ASTERISK(int i) {
12603                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12604                }
12605                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12606                public TerminalNode WS(int i) {
12607                        return getToken(JavadocParser.WS, i);
12608                }
12609                public FrameTagContext(ParserRuleContext parent, int invokingState) {
12610                        super(parent, invokingState);
12611                }
12612                @Override public int getRuleIndex() { return RULE_frameTag; }
12613                @Override
12614                public void enterRule(ParseTreeListener listener) {
12615                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this);
12616                }
12617                @Override
12618                public void exitRule(ParseTreeListener listener) {
12619                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this);
12620                }
12621                @Override
12622                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12623                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this);
12624                        else return visitor.visitChildren(this);
12625                }
12626        }
12627
12628        public final FrameTagContext frameTag() throws RecognitionException {
12629                FrameTagContext _localctx = new FrameTagContext(_ctx, getState());
12630                enterRule(_localctx, 116, RULE_frameTag);
12631                int _la;
12632                try {
12633                        enterOuterAlt(_localctx, 1);
12634                        {
12635                        setState(1436);
12636                        match(OPEN);
12637                        setState(1437);
12638                        match(FRAME_HTML_TAG_NAME);
12639                        setState(1444);
12640                        _errHandler.sync(this);
12641                        _la = _input.LA(1);
12642                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12643                                {
12644                                setState(1442);
12645                                switch (_input.LA(1)) {
12646                                case HTML_TAG_NAME:
12647                                        {
12648                                        setState(1438);
12649                                        attribute();
12650                                        }
12651                                        break;
12652                                case NEWLINE:
12653                                        {
12654                                        setState(1439);
12655                                        match(NEWLINE);
12656                                        }
12657                                        break;
12658                                case LEADING_ASTERISK:
12659                                        {
12660                                        setState(1440);
12661                                        match(LEADING_ASTERISK);
12662                                        }
12663                                        break;
12664                                case WS:
12665                                        {
12666                                        setState(1441);
12667                                        match(WS);
12668                                        }
12669                                        break;
12670                                default:
12671                                        throw new NoViableAltException(this);
12672                                }
12673                                }
12674                                setState(1446);
12675                                _errHandler.sync(this);
12676                                _la = _input.LA(1);
12677                        }
12678                        setState(1447);
12679                        _la = _input.LA(1);
12680                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12681                        _errHandler.recoverInline(this);
12682                        } else {
12683                                consume();
12684                        }
12685                        }
12686                }
12687                catch (RecognitionException re) {
12688                        _localctx.exception = re;
12689                        _errHandler.reportError(this, re);
12690                        _errHandler.recover(this, re);
12691                }
12692                finally {
12693                        exitRule();
12694                }
12695                return _localctx;
12696        }
12697
12698        public static class HrTagContext extends ParserRuleContext {
12699                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12700                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
12701                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12702                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12703                public List<AttributeContext> attribute() {
12704                        return getRuleContexts(AttributeContext.class);
12705                }
12706                public AttributeContext attribute(int i) {
12707                        return getRuleContext(AttributeContext.class,i);
12708                }
12709                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12710                public TerminalNode NEWLINE(int i) {
12711                        return getToken(JavadocParser.NEWLINE, i);
12712                }
12713                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12714                public TerminalNode LEADING_ASTERISK(int i) {
12715                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12716                }
12717                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12718                public TerminalNode WS(int i) {
12719                        return getToken(JavadocParser.WS, i);
12720                }
12721                public HrTagContext(ParserRuleContext parent, int invokingState) {
12722                        super(parent, invokingState);
12723                }
12724                @Override public int getRuleIndex() { return RULE_hrTag; }
12725                @Override
12726                public void enterRule(ParseTreeListener listener) {
12727                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this);
12728                }
12729                @Override
12730                public void exitRule(ParseTreeListener listener) {
12731                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this);
12732                }
12733                @Override
12734                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12735                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this);
12736                        else return visitor.visitChildren(this);
12737                }
12738        }
12739
12740        public final HrTagContext hrTag() throws RecognitionException {
12741                HrTagContext _localctx = new HrTagContext(_ctx, getState());
12742                enterRule(_localctx, 118, RULE_hrTag);
12743                int _la;
12744                try {
12745                        enterOuterAlt(_localctx, 1);
12746                        {
12747                        setState(1449);
12748                        match(OPEN);
12749                        setState(1450);
12750                        match(HR_HTML_TAG_NAME);
12751                        setState(1457);
12752                        _errHandler.sync(this);
12753                        _la = _input.LA(1);
12754                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12755                                {
12756                                setState(1455);
12757                                switch (_input.LA(1)) {
12758                                case HTML_TAG_NAME:
12759                                        {
12760                                        setState(1451);
12761                                        attribute();
12762                                        }
12763                                        break;
12764                                case NEWLINE:
12765                                        {
12766                                        setState(1452);
12767                                        match(NEWLINE);
12768                                        }
12769                                        break;
12770                                case LEADING_ASTERISK:
12771                                        {
12772                                        setState(1453);
12773                                        match(LEADING_ASTERISK);
12774                                        }
12775                                        break;
12776                                case WS:
12777                                        {
12778                                        setState(1454);
12779                                        match(WS);
12780                                        }
12781                                        break;
12782                                default:
12783                                        throw new NoViableAltException(this);
12784                                }
12785                                }
12786                                setState(1459);
12787                                _errHandler.sync(this);
12788                                _la = _input.LA(1);
12789                        }
12790                        setState(1460);
12791                        _la = _input.LA(1);
12792                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12793                        _errHandler.recoverInline(this);
12794                        } else {
12795                                consume();
12796                        }
12797                        }
12798                }
12799                catch (RecognitionException re) {
12800                        _localctx.exception = re;
12801                        _errHandler.reportError(this, re);
12802                        _errHandler.recover(this, re);
12803                }
12804                finally {
12805                        exitRule();
12806                }
12807                return _localctx;
12808        }
12809
12810        public static class ImgTagContext extends ParserRuleContext {
12811                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12812                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
12813                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12814                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12815                public List<AttributeContext> attribute() {
12816                        return getRuleContexts(AttributeContext.class);
12817                }
12818                public AttributeContext attribute(int i) {
12819                        return getRuleContext(AttributeContext.class,i);
12820                }
12821                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12822                public TerminalNode NEWLINE(int i) {
12823                        return getToken(JavadocParser.NEWLINE, i);
12824                }
12825                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12826                public TerminalNode LEADING_ASTERISK(int i) {
12827                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12828                }
12829                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12830                public TerminalNode WS(int i) {
12831                        return getToken(JavadocParser.WS, i);
12832                }
12833                public ImgTagContext(ParserRuleContext parent, int invokingState) {
12834                        super(parent, invokingState);
12835                }
12836                @Override public int getRuleIndex() { return RULE_imgTag; }
12837                @Override
12838                public void enterRule(ParseTreeListener listener) {
12839                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this);
12840                }
12841                @Override
12842                public void exitRule(ParseTreeListener listener) {
12843                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this);
12844                }
12845                @Override
12846                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12847                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this);
12848                        else return visitor.visitChildren(this);
12849                }
12850        }
12851
12852        public final ImgTagContext imgTag() throws RecognitionException {
12853                ImgTagContext _localctx = new ImgTagContext(_ctx, getState());
12854                enterRule(_localctx, 120, RULE_imgTag);
12855                int _la;
12856                try {
12857                        enterOuterAlt(_localctx, 1);
12858                        {
12859                        setState(1462);
12860                        match(OPEN);
12861                        setState(1463);
12862                        match(IMG_HTML_TAG_NAME);
12863                        setState(1470);
12864                        _errHandler.sync(this);
12865                        _la = _input.LA(1);
12866                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12867                                {
12868                                setState(1468);
12869                                switch (_input.LA(1)) {
12870                                case HTML_TAG_NAME:
12871                                        {
12872                                        setState(1464);
12873                                        attribute();
12874                                        }
12875                                        break;
12876                                case NEWLINE:
12877                                        {
12878                                        setState(1465);
12879                                        match(NEWLINE);
12880                                        }
12881                                        break;
12882                                case LEADING_ASTERISK:
12883                                        {
12884                                        setState(1466);
12885                                        match(LEADING_ASTERISK);
12886                                        }
12887                                        break;
12888                                case WS:
12889                                        {
12890                                        setState(1467);
12891                                        match(WS);
12892                                        }
12893                                        break;
12894                                default:
12895                                        throw new NoViableAltException(this);
12896                                }
12897                                }
12898                                setState(1472);
12899                                _errHandler.sync(this);
12900                                _la = _input.LA(1);
12901                        }
12902                        setState(1473);
12903                        _la = _input.LA(1);
12904                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
12905                        _errHandler.recoverInline(this);
12906                        } else {
12907                                consume();
12908                        }
12909                        }
12910                }
12911                catch (RecognitionException re) {
12912                        _localctx.exception = re;
12913                        _errHandler.reportError(this, re);
12914                        _errHandler.recover(this, re);
12915                }
12916                finally {
12917                        exitRule();
12918                }
12919                return _localctx;
12920        }
12921
12922        public static class InputTagContext extends ParserRuleContext {
12923                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
12924                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
12925                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
12926                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
12927                public List<AttributeContext> attribute() {
12928                        return getRuleContexts(AttributeContext.class);
12929                }
12930                public AttributeContext attribute(int i) {
12931                        return getRuleContext(AttributeContext.class,i);
12932                }
12933                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
12934                public TerminalNode NEWLINE(int i) {
12935                        return getToken(JavadocParser.NEWLINE, i);
12936                }
12937                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
12938                public TerminalNode LEADING_ASTERISK(int i) {
12939                        return getToken(JavadocParser.LEADING_ASTERISK, i);
12940                }
12941                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
12942                public TerminalNode WS(int i) {
12943                        return getToken(JavadocParser.WS, i);
12944                }
12945                public InputTagContext(ParserRuleContext parent, int invokingState) {
12946                        super(parent, invokingState);
12947                }
12948                @Override public int getRuleIndex() { return RULE_inputTag; }
12949                @Override
12950                public void enterRule(ParseTreeListener listener) {
12951                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this);
12952                }
12953                @Override
12954                public void exitRule(ParseTreeListener listener) {
12955                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this);
12956                }
12957                @Override
12958                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
12959                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this);
12960                        else return visitor.visitChildren(this);
12961                }
12962        }
12963
12964        public final InputTagContext inputTag() throws RecognitionException {
12965                InputTagContext _localctx = new InputTagContext(_ctx, getState());
12966                enterRule(_localctx, 122, RULE_inputTag);
12967                int _la;
12968                try {
12969                        enterOuterAlt(_localctx, 1);
12970                        {
12971                        setState(1475);
12972                        match(OPEN);
12973                        setState(1476);
12974                        match(INPUT_HTML_TAG_NAME);
12975                        setState(1483);
12976                        _errHandler.sync(this);
12977                        _la = _input.LA(1);
12978                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
12979                                {
12980                                setState(1481);
12981                                switch (_input.LA(1)) {
12982                                case HTML_TAG_NAME:
12983                                        {
12984                                        setState(1477);
12985                                        attribute();
12986                                        }
12987                                        break;
12988                                case NEWLINE:
12989                                        {
12990                                        setState(1478);
12991                                        match(NEWLINE);
12992                                        }
12993                                        break;
12994                                case LEADING_ASTERISK:
12995                                        {
12996                                        setState(1479);
12997                                        match(LEADING_ASTERISK);
12998                                        }
12999                                        break;
13000                                case WS:
13001                                        {
13002                                        setState(1480);
13003                                        match(WS);
13004                                        }
13005                                        break;
13006                                default:
13007                                        throw new NoViableAltException(this);
13008                                }
13009                                }
13010                                setState(1485);
13011                                _errHandler.sync(this);
13012                                _la = _input.LA(1);
13013                        }
13014                        setState(1486);
13015                        _la = _input.LA(1);
13016                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13017                        _errHandler.recoverInline(this);
13018                        } else {
13019                                consume();
13020                        }
13021                        }
13022                }
13023                catch (RecognitionException re) {
13024                        _localctx.exception = re;
13025                        _errHandler.reportError(this, re);
13026                        _errHandler.recover(this, re);
13027                }
13028                finally {
13029                        exitRule();
13030                }
13031                return _localctx;
13032        }
13033
13034        public static class IsindexTagContext extends ParserRuleContext {
13035                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13036                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13037                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13038                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13039                public List<AttributeContext> attribute() {
13040                        return getRuleContexts(AttributeContext.class);
13041                }
13042                public AttributeContext attribute(int i) {
13043                        return getRuleContext(AttributeContext.class,i);
13044                }
13045                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13046                public TerminalNode NEWLINE(int i) {
13047                        return getToken(JavadocParser.NEWLINE, i);
13048                }
13049                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13050                public TerminalNode LEADING_ASTERISK(int i) {
13051                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13052                }
13053                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13054                public TerminalNode WS(int i) {
13055                        return getToken(JavadocParser.WS, i);
13056                }
13057                public IsindexTagContext(ParserRuleContext parent, int invokingState) {
13058                        super(parent, invokingState);
13059                }
13060                @Override public int getRuleIndex() { return RULE_isindexTag; }
13061                @Override
13062                public void enterRule(ParseTreeListener listener) {
13063                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this);
13064                }
13065                @Override
13066                public void exitRule(ParseTreeListener listener) {
13067                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this);
13068                }
13069                @Override
13070                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13071                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this);
13072                        else return visitor.visitChildren(this);
13073                }
13074        }
13075
13076        public final IsindexTagContext isindexTag() throws RecognitionException {
13077                IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState());
13078                enterRule(_localctx, 124, RULE_isindexTag);
13079                int _la;
13080                try {
13081                        enterOuterAlt(_localctx, 1);
13082                        {
13083                        setState(1488);
13084                        match(OPEN);
13085                        setState(1489);
13086                        match(ISINDEX_HTML_TAG_NAME);
13087                        setState(1496);
13088                        _errHandler.sync(this);
13089                        _la = _input.LA(1);
13090                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13091                                {
13092                                setState(1494);
13093                                switch (_input.LA(1)) {
13094                                case HTML_TAG_NAME:
13095                                        {
13096                                        setState(1490);
13097                                        attribute();
13098                                        }
13099                                        break;
13100                                case NEWLINE:
13101                                        {
13102                                        setState(1491);
13103                                        match(NEWLINE);
13104                                        }
13105                                        break;
13106                                case LEADING_ASTERISK:
13107                                        {
13108                                        setState(1492);
13109                                        match(LEADING_ASTERISK);
13110                                        }
13111                                        break;
13112                                case WS:
13113                                        {
13114                                        setState(1493);
13115                                        match(WS);
13116                                        }
13117                                        break;
13118                                default:
13119                                        throw new NoViableAltException(this);
13120                                }
13121                                }
13122                                setState(1498);
13123                                _errHandler.sync(this);
13124                                _la = _input.LA(1);
13125                        }
13126                        setState(1499);
13127                        _la = _input.LA(1);
13128                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13129                        _errHandler.recoverInline(this);
13130                        } else {
13131                                consume();
13132                        }
13133                        }
13134                }
13135                catch (RecognitionException re) {
13136                        _localctx.exception = re;
13137                        _errHandler.reportError(this, re);
13138                        _errHandler.recover(this, re);
13139                }
13140                finally {
13141                        exitRule();
13142                }
13143                return _localctx;
13144        }
13145
13146        public static class LinkTagContext extends ParserRuleContext {
13147                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13148                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13149                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13150                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13151                public List<AttributeContext> attribute() {
13152                        return getRuleContexts(AttributeContext.class);
13153                }
13154                public AttributeContext attribute(int i) {
13155                        return getRuleContext(AttributeContext.class,i);
13156                }
13157                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13158                public TerminalNode NEWLINE(int i) {
13159                        return getToken(JavadocParser.NEWLINE, i);
13160                }
13161                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13162                public TerminalNode LEADING_ASTERISK(int i) {
13163                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13164                }
13165                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13166                public TerminalNode WS(int i) {
13167                        return getToken(JavadocParser.WS, i);
13168                }
13169                public LinkTagContext(ParserRuleContext parent, int invokingState) {
13170                        super(parent, invokingState);
13171                }
13172                @Override public int getRuleIndex() { return RULE_linkTag; }
13173                @Override
13174                public void enterRule(ParseTreeListener listener) {
13175                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this);
13176                }
13177                @Override
13178                public void exitRule(ParseTreeListener listener) {
13179                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this);
13180                }
13181                @Override
13182                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13183                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this);
13184                        else return visitor.visitChildren(this);
13185                }
13186        }
13187
13188        public final LinkTagContext linkTag() throws RecognitionException {
13189                LinkTagContext _localctx = new LinkTagContext(_ctx, getState());
13190                enterRule(_localctx, 126, RULE_linkTag);
13191                int _la;
13192                try {
13193                        enterOuterAlt(_localctx, 1);
13194                        {
13195                        setState(1501);
13196                        match(OPEN);
13197                        setState(1502);
13198                        match(LINK_HTML_TAG_NAME);
13199                        setState(1509);
13200                        _errHandler.sync(this);
13201                        _la = _input.LA(1);
13202                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13203                                {
13204                                setState(1507);
13205                                switch (_input.LA(1)) {
13206                                case HTML_TAG_NAME:
13207                                        {
13208                                        setState(1503);
13209                                        attribute();
13210                                        }
13211                                        break;
13212                                case NEWLINE:
13213                                        {
13214                                        setState(1504);
13215                                        match(NEWLINE);
13216                                        }
13217                                        break;
13218                                case LEADING_ASTERISK:
13219                                        {
13220                                        setState(1505);
13221                                        match(LEADING_ASTERISK);
13222                                        }
13223                                        break;
13224                                case WS:
13225                                        {
13226                                        setState(1506);
13227                                        match(WS);
13228                                        }
13229                                        break;
13230                                default:
13231                                        throw new NoViableAltException(this);
13232                                }
13233                                }
13234                                setState(1511);
13235                                _errHandler.sync(this);
13236                                _la = _input.LA(1);
13237                        }
13238                        setState(1512);
13239                        _la = _input.LA(1);
13240                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13241                        _errHandler.recoverInline(this);
13242                        } else {
13243                                consume();
13244                        }
13245                        }
13246                }
13247                catch (RecognitionException re) {
13248                        _localctx.exception = re;
13249                        _errHandler.reportError(this, re);
13250                        _errHandler.recover(this, re);
13251                }
13252                finally {
13253                        exitRule();
13254                }
13255                return _localctx;
13256        }
13257
13258        public static class MetaTagContext extends ParserRuleContext {
13259                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13260                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13261                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13262                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13263                public List<AttributeContext> attribute() {
13264                        return getRuleContexts(AttributeContext.class);
13265                }
13266                public AttributeContext attribute(int i) {
13267                        return getRuleContext(AttributeContext.class,i);
13268                }
13269                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13270                public TerminalNode NEWLINE(int i) {
13271                        return getToken(JavadocParser.NEWLINE, i);
13272                }
13273                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13274                public TerminalNode LEADING_ASTERISK(int i) {
13275                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13276                }
13277                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13278                public TerminalNode WS(int i) {
13279                        return getToken(JavadocParser.WS, i);
13280                }
13281                public MetaTagContext(ParserRuleContext parent, int invokingState) {
13282                        super(parent, invokingState);
13283                }
13284                @Override public int getRuleIndex() { return RULE_metaTag; }
13285                @Override
13286                public void enterRule(ParseTreeListener listener) {
13287                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this);
13288                }
13289                @Override
13290                public void exitRule(ParseTreeListener listener) {
13291                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this);
13292                }
13293                @Override
13294                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13295                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this);
13296                        else return visitor.visitChildren(this);
13297                }
13298        }
13299
13300        public final MetaTagContext metaTag() throws RecognitionException {
13301                MetaTagContext _localctx = new MetaTagContext(_ctx, getState());
13302                enterRule(_localctx, 128, RULE_metaTag);
13303                int _la;
13304                try {
13305                        enterOuterAlt(_localctx, 1);
13306                        {
13307                        setState(1514);
13308                        match(OPEN);
13309                        setState(1515);
13310                        match(META_HTML_TAG_NAME);
13311                        setState(1522);
13312                        _errHandler.sync(this);
13313                        _la = _input.LA(1);
13314                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13315                                {
13316                                setState(1520);
13317                                switch (_input.LA(1)) {
13318                                case HTML_TAG_NAME:
13319                                        {
13320                                        setState(1516);
13321                                        attribute();
13322                                        }
13323                                        break;
13324                                case NEWLINE:
13325                                        {
13326                                        setState(1517);
13327                                        match(NEWLINE);
13328                                        }
13329                                        break;
13330                                case LEADING_ASTERISK:
13331                                        {
13332                                        setState(1518);
13333                                        match(LEADING_ASTERISK);
13334                                        }
13335                                        break;
13336                                case WS:
13337                                        {
13338                                        setState(1519);
13339                                        match(WS);
13340                                        }
13341                                        break;
13342                                default:
13343                                        throw new NoViableAltException(this);
13344                                }
13345                                }
13346                                setState(1524);
13347                                _errHandler.sync(this);
13348                                _la = _input.LA(1);
13349                        }
13350                        setState(1525);
13351                        _la = _input.LA(1);
13352                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13353                        _errHandler.recoverInline(this);
13354                        } else {
13355                                consume();
13356                        }
13357                        }
13358                }
13359                catch (RecognitionException re) {
13360                        _localctx.exception = re;
13361                        _errHandler.reportError(this, re);
13362                        _errHandler.recover(this, re);
13363                }
13364                finally {
13365                        exitRule();
13366                }
13367                return _localctx;
13368        }
13369
13370        public static class ParamTagContext extends ParserRuleContext {
13371                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13372                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13373                public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); }
13374                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13375                public List<AttributeContext> attribute() {
13376                        return getRuleContexts(AttributeContext.class);
13377                }
13378                public AttributeContext attribute(int i) {
13379                        return getRuleContext(AttributeContext.class,i);
13380                }
13381                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13382                public TerminalNode NEWLINE(int i) {
13383                        return getToken(JavadocParser.NEWLINE, i);
13384                }
13385                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13386                public TerminalNode LEADING_ASTERISK(int i) {
13387                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13388                }
13389                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13390                public TerminalNode WS(int i) {
13391                        return getToken(JavadocParser.WS, i);
13392                }
13393                public ParamTagContext(ParserRuleContext parent, int invokingState) {
13394                        super(parent, invokingState);
13395                }
13396                @Override public int getRuleIndex() { return RULE_paramTag; }
13397                @Override
13398                public void enterRule(ParseTreeListener listener) {
13399                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this);
13400                }
13401                @Override
13402                public void exitRule(ParseTreeListener listener) {
13403                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this);
13404                }
13405                @Override
13406                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13407                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this);
13408                        else return visitor.visitChildren(this);
13409                }
13410        }
13411
13412        public final ParamTagContext paramTag() throws RecognitionException {
13413                ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
13414                enterRule(_localctx, 130, RULE_paramTag);
13415                int _la;
13416                try {
13417                        enterOuterAlt(_localctx, 1);
13418                        {
13419                        setState(1527);
13420                        match(OPEN);
13421                        setState(1528);
13422                        match(PARAM_HTML_TAG_NAME);
13423                        setState(1535);
13424                        _errHandler.sync(this);
13425                        _la = _input.LA(1);
13426                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) {
13427                                {
13428                                setState(1533);
13429                                switch (_input.LA(1)) {
13430                                case HTML_TAG_NAME:
13431                                        {
13432                                        setState(1529);
13433                                        attribute();
13434                                        }
13435                                        break;
13436                                case NEWLINE:
13437                                        {
13438                                        setState(1530);
13439                                        match(NEWLINE);
13440                                        }
13441                                        break;
13442                                case LEADING_ASTERISK:
13443                                        {
13444                                        setState(1531);
13445                                        match(LEADING_ASTERISK);
13446                                        }
13447                                        break;
13448                                case WS:
13449                                        {
13450                                        setState(1532);
13451                                        match(WS);
13452                                        }
13453                                        break;
13454                                default:
13455                                        throw new NoViableAltException(this);
13456                                }
13457                                }
13458                                setState(1537);
13459                                _errHandler.sync(this);
13460                                _la = _input.LA(1);
13461                        }
13462                        setState(1538);
13463                        _la = _input.LA(1);
13464                        if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) {
13465                        _errHandler.recoverInline(this);
13466                        } else {
13467                                consume();
13468                        }
13469                        }
13470                }
13471                catch (RecognitionException re) {
13472                        _localctx.exception = re;
13473                        _errHandler.reportError(this, re);
13474                        _errHandler.recover(this, re);
13475                }
13476                finally {
13477                        exitRule();
13478                }
13479                return _localctx;
13480        }
13481
13482        public static class WrongSinletonTagContext extends ParserRuleContext {
13483                public SingletonTagNameContext singletonTagName;
13484                public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); }
13485                public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
13486                public SingletonTagNameContext singletonTagName() {
13487                        return getRuleContext(SingletonTagNameContext.class,0);
13488                }
13489                public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); }
13490                public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) {
13491                        super(parent, invokingState);
13492                }
13493                @Override public int getRuleIndex() { return RULE_wrongSinletonTag; }
13494                @Override
13495                public void enterRule(ParseTreeListener listener) {
13496                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this);
13497                }
13498                @Override
13499                public void exitRule(ParseTreeListener listener) {
13500                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this);
13501                }
13502                @Override
13503                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13504                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this);
13505                        else return visitor.visitChildren(this);
13506                }
13507        }
13508
13509        public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException {
13510                WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState());
13511                enterRule(_localctx, 132, RULE_wrongSinletonTag);
13512                try {
13513                        enterOuterAlt(_localctx, 1);
13514                        {
13515                        setState(1540);
13516                        match(OPEN);
13517                        setState(1541);
13518                        match(SLASH);
13519                        setState(1542);
13520                        ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName();
13521                        setState(1543);
13522                        match(CLOSE);
13523                        notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), "javadoc.wrong.singleton.html.tag", null);
13524                        }
13525                }
13526                catch (RecognitionException re) {
13527                        _localctx.exception = re;
13528                        _errHandler.reportError(this, re);
13529                        _errHandler.recover(this, re);
13530                }
13531                finally {
13532                        exitRule();
13533                }
13534                return _localctx;
13535        }
13536
13537        public static class SingletonTagNameContext extends ParserRuleContext {
13538                public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); }
13539                public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); }
13540                public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); }
13541                public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); }
13542                public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); }
13543                public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); }
13544                public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); }
13545                public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); }
13546                public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); }
13547                public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); }
13548                public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); }
13549                public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); }
13550                public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); }
13551                public SingletonTagNameContext(ParserRuleContext parent, int invokingState) {
13552                        super(parent, invokingState);
13553                }
13554                @Override public int getRuleIndex() { return RULE_singletonTagName; }
13555                @Override
13556                public void enterRule(ParseTreeListener listener) {
13557                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this);
13558                }
13559                @Override
13560                public void exitRule(ParseTreeListener listener) {
13561                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this);
13562                }
13563                @Override
13564                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13565                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this);
13566                        else return visitor.visitChildren(this);
13567                }
13568        }
13569
13570        public final SingletonTagNameContext singletonTagName() throws RecognitionException {
13571                SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState());
13572                enterRule(_localctx, 134, RULE_singletonTagName);
13573                int _la;
13574                try {
13575                        enterOuterAlt(_localctx, 1);
13576                        {
13577                        setState(1546);
13578                        _la = _input.LA(1);
13579                        if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFRONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)))) != 0)) ) {
13580                        _errHandler.recoverInline(this);
13581                        } else {
13582                                consume();
13583                        }
13584                        }
13585                }
13586                catch (RecognitionException re) {
13587                        _localctx.exception = re;
13588                        _errHandler.reportError(this, re);
13589                        _errHandler.recover(this, re);
13590                }
13591                finally {
13592                        exitRule();
13593                }
13594                return _localctx;
13595        }
13596
13597        public static class DescriptionContext extends ParserRuleContext {
13598                public List<HtmlCommentContext> htmlComment() {
13599                        return getRuleContexts(HtmlCommentContext.class);
13600                }
13601                public HtmlCommentContext htmlComment(int i) {
13602                        return getRuleContext(HtmlCommentContext.class,i);
13603                }
13604                public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); }
13605                public TerminalNode CDATA(int i) {
13606                        return getToken(JavadocParser.CDATA, i);
13607                }
13608                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13609                public TerminalNode NEWLINE(int i) {
13610                        return getToken(JavadocParser.NEWLINE, i);
13611                }
13612                public List<TextContext> text() {
13613                        return getRuleContexts(TextContext.class);
13614                }
13615                public TextContext text(int i) {
13616                        return getRuleContext(TextContext.class,i);
13617                }
13618                public List<JavadocInlineTagContext> javadocInlineTag() {
13619                        return getRuleContexts(JavadocInlineTagContext.class);
13620                }
13621                public JavadocInlineTagContext javadocInlineTag(int i) {
13622                        return getRuleContext(JavadocInlineTagContext.class,i);
13623                }
13624                public List<HtmlElementContext> htmlElement() {
13625                        return getRuleContexts(HtmlElementContext.class);
13626                }
13627                public HtmlElementContext htmlElement(int i) {
13628                        return getRuleContext(HtmlElementContext.class,i);
13629                }
13630                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13631                public TerminalNode LEADING_ASTERISK(int i) {
13632                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13633                }
13634                public DescriptionContext(ParserRuleContext parent, int invokingState) {
13635                        super(parent, invokingState);
13636                }
13637                @Override public int getRuleIndex() { return RULE_description; }
13638                @Override
13639                public void enterRule(ParseTreeListener listener) {
13640                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
13641                }
13642                @Override
13643                public void exitRule(ParseTreeListener listener) {
13644                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
13645                }
13646                @Override
13647                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13648                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
13649                        else return visitor.visitChildren(this);
13650                }
13651        }
13652
13653        public final DescriptionContext description() throws RecognitionException {
13654                DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
13655                enterRule(_localctx, 136, RULE_description);
13656                try {
13657                        int _alt;
13658                        enterOuterAlt(_localctx, 1);
13659                        {
13660                        setState(1556); 
13661                        _errHandler.sync(this);
13662                        _alt = 1;
13663                        do {
13664                                switch (_alt) {
13665                                case 1:
13666                                        {
13667                                        setState(1556);
13668                                        _errHandler.sync(this);
13669                                        switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
13670                                        case 1:
13671                                                {
13672                                                {
13673                                                setState(1548);
13674                                                if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()");
13675                                                setState(1549);
13676                                                match(LEADING_ASTERISK);
13677                                                }
13678                                                }
13679                                                break;
13680                                        case 2:
13681                                                {
13682                                                setState(1550);
13683                                                htmlComment();
13684                                                }
13685                                                break;
13686                                        case 3:
13687                                                {
13688                                                setState(1551);
13689                                                match(CDATA);
13690                                                }
13691                                                break;
13692                                        case 4:
13693                                                {
13694                                                setState(1552);
13695                                                match(NEWLINE);
13696                                                }
13697                                                break;
13698                                        case 5:
13699                                                {
13700                                                setState(1553);
13701                                                text();
13702                                                }
13703                                                break;
13704                                        case 6:
13705                                                {
13706                                                setState(1554);
13707                                                javadocInlineTag();
13708                                                }
13709                                                break;
13710                                        case 7:
13711                                                {
13712                                                setState(1555);
13713                                                htmlElement();
13714                                                }
13715                                                break;
13716                                        }
13717                                        }
13718                                        break;
13719                                default:
13720                                        throw new NoViableAltException(this);
13721                                }
13722                                setState(1558); 
13723                                _errHandler.sync(this);
13724                                _alt = getInterpreter().adaptivePredict(_input,122,_ctx);
13725                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13726                        }
13727                }
13728                catch (RecognitionException re) {
13729                        _localctx.exception = re;
13730                        _errHandler.reportError(this, re);
13731                        _errHandler.recover(this, re);
13732                }
13733                finally {
13734                        exitRule();
13735                }
13736                return _localctx;
13737        }
13738
13739        public static class ReferenceContext extends ParserRuleContext {
13740                public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); }
13741                public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); }
13742                public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); }
13743                public ParametersContext parameters() {
13744                        return getRuleContext(ParametersContext.class,0);
13745                }
13746                public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); }
13747                public TerminalNode DOT(int i) {
13748                        return getToken(JavadocParser.DOT, i);
13749                }
13750                public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); }
13751                public TerminalNode CLASS(int i) {
13752                        return getToken(JavadocParser.CLASS, i);
13753                }
13754                public ReferenceContext(ParserRuleContext parent, int invokingState) {
13755                        super(parent, invokingState);
13756                }
13757                @Override public int getRuleIndex() { return RULE_reference; }
13758                @Override
13759                public void enterRule(ParseTreeListener listener) {
13760                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this);
13761                }
13762                @Override
13763                public void exitRule(ParseTreeListener listener) {
13764                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this);
13765                }
13766                @Override
13767                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13768                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this);
13769                        else return visitor.visitChildren(this);
13770                }
13771        }
13772
13773        public final ReferenceContext reference() throws RecognitionException {
13774                ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
13775                enterRule(_localctx, 138, RULE_reference);
13776                int _la;
13777                try {
13778                        int _alt;
13779                        enterOuterAlt(_localctx, 1);
13780                        {
13781                        setState(1597);
13782                        switch (_input.LA(1)) {
13783                        case PACKAGE:
13784                                {
13785                                setState(1560);
13786                                match(PACKAGE);
13787                                setState(1564);
13788                                _errHandler.sync(this);
13789                                _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13790                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13791                                        if ( _alt==1 ) {
13792                                                {
13793                                                {
13794                                                setState(1561);
13795                                                _la = _input.LA(1);
13796                                                if ( !(_la==DOT || _la==CLASS) ) {
13797                                                _errHandler.recoverInline(this);
13798                                                } else {
13799                                                        consume();
13800                                                }
13801                                                }
13802                                                } 
13803                                        }
13804                                        setState(1566);
13805                                        _errHandler.sync(this);
13806                                        _alt = getInterpreter().adaptivePredict(_input,123,_ctx);
13807                                }
13808                                setState(1568);
13809                                _errHandler.sync(this);
13810                                switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
13811                                case 1:
13812                                        {
13813                                        setState(1567);
13814                                        match(HASH);
13815                                        }
13816                                        break;
13817                                }
13818                                setState(1571);
13819                                _errHandler.sync(this);
13820                                switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
13821                                case 1:
13822                                        {
13823                                        setState(1570);
13824                                        match(MEMBER);
13825                                        }
13826                                        break;
13827                                }
13828                                setState(1574);
13829                                _errHandler.sync(this);
13830                                switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
13831                                case 1:
13832                                        {
13833                                        setState(1573);
13834                                        parameters();
13835                                        }
13836                                        break;
13837                                }
13838                                }
13839                                break;
13840                        case DOT:
13841                        case CLASS:
13842                                {
13843                                setState(1577); 
13844                                _errHandler.sync(this);
13845                                _alt = 1;
13846                                do {
13847                                        switch (_alt) {
13848                                        case 1:
13849                                                {
13850                                                {
13851                                                setState(1576);
13852                                                _la = _input.LA(1);
13853                                                if ( !(_la==DOT || _la==CLASS) ) {
13854                                                _errHandler.recoverInline(this);
13855                                                } else {
13856                                                        consume();
13857                                                }
13858                                                }
13859                                                }
13860                                                break;
13861                                        default:
13862                                                throw new NoViableAltException(this);
13863                                        }
13864                                        setState(1579); 
13865                                        _errHandler.sync(this);
13866                                        _alt = getInterpreter().adaptivePredict(_input,127,_ctx);
13867                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
13868                                setState(1582);
13869                                _errHandler.sync(this);
13870                                switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
13871                                case 1:
13872                                        {
13873                                        setState(1581);
13874                                        match(HASH);
13875                                        }
13876                                        break;
13877                                }
13878                                setState(1585);
13879                                _errHandler.sync(this);
13880                                switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
13881                                case 1:
13882                                        {
13883                                        setState(1584);
13884                                        match(MEMBER);
13885                                        }
13886                                        break;
13887                                }
13888                                setState(1588);
13889                                _errHandler.sync(this);
13890                                switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
13891                                case 1:
13892                                        {
13893                                        setState(1587);
13894                                        parameters();
13895                                        }
13896                                        break;
13897                                }
13898                                }
13899                                break;
13900                        case HASH:
13901                        case MEMBER:
13902                                {
13903                                setState(1591);
13904                                _la = _input.LA(1);
13905                                if (_la==HASH) {
13906                                        {
13907                                        setState(1590);
13908                                        match(HASH);
13909                                        }
13910                                }
13911
13912                                setState(1593);
13913                                match(MEMBER);
13914                                setState(1595);
13915                                _errHandler.sync(this);
13916                                switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
13917                                case 1:
13918                                        {
13919                                        setState(1594);
13920                                        parameters();
13921                                        }
13922                                        break;
13923                                }
13924                                }
13925                                break;
13926                        default:
13927                                throw new NoViableAltException(this);
13928                        }
13929                        }
13930                }
13931                catch (RecognitionException re) {
13932                        _localctx.exception = re;
13933                        _errHandler.reportError(this, re);
13934                        _errHandler.recover(this, re);
13935                }
13936                finally {
13937                        exitRule();
13938                }
13939                return _localctx;
13940        }
13941
13942        public static class ParametersContext extends ParserRuleContext {
13943                public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); }
13944                public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); }
13945                public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); }
13946                public TerminalNode ARGUMENT(int i) {
13947                        return getToken(JavadocParser.ARGUMENT, i);
13948                }
13949                public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); }
13950                public TerminalNode COMMA(int i) {
13951                        return getToken(JavadocParser.COMMA, i);
13952                }
13953                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
13954                public TerminalNode WS(int i) {
13955                        return getToken(JavadocParser.WS, i);
13956                }
13957                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
13958                public TerminalNode NEWLINE(int i) {
13959                        return getToken(JavadocParser.NEWLINE, i);
13960                }
13961                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
13962                public TerminalNode LEADING_ASTERISK(int i) {
13963                        return getToken(JavadocParser.LEADING_ASTERISK, i);
13964                }
13965                public ParametersContext(ParserRuleContext parent, int invokingState) {
13966                        super(parent, invokingState);
13967                }
13968                @Override public int getRuleIndex() { return RULE_parameters; }
13969                @Override
13970                public void enterRule(ParseTreeListener listener) {
13971                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this);
13972                }
13973                @Override
13974                public void exitRule(ParseTreeListener listener) {
13975                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this);
13976                }
13977                @Override
13978                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
13979                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this);
13980                        else return visitor.visitChildren(this);
13981                }
13982        }
13983
13984        public final ParametersContext parameters() throws RecognitionException {
13985                ParametersContext _localctx = new ParametersContext(_ctx, getState());
13986                enterRule(_localctx, 140, RULE_parameters);
13987                int _la;
13988                try {
13989                        enterOuterAlt(_localctx, 1);
13990                        {
13991                        setState(1599);
13992                        match(LEFT_BRACE);
13993                        setState(1603);
13994                        _errHandler.sync(this);
13995                        _la = _input.LA(1);
13996                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) {
13997                                {
13998                                {
13999                                setState(1600);
14000                                _la = _input.LA(1);
14001                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) {
14002                                _errHandler.recoverInline(this);
14003                                } else {
14004                                        consume();
14005                                }
14006                                }
14007                                }
14008                                setState(1605);
14009                                _errHandler.sync(this);
14010                                _la = _input.LA(1);
14011                        }
14012                        setState(1606);
14013                        match(RIGHT_BRACE);
14014                        }
14015                }
14016                catch (RecognitionException re) {
14017                        _localctx.exception = re;
14018                        _errHandler.reportError(this, re);
14019                        _errHandler.recover(this, re);
14020                }
14021                finally {
14022                        exitRule();
14023                }
14024                return _localctx;
14025        }
14026
14027        public static class JavadocTagContext extends ParserRuleContext {
14028                public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); }
14029                public DescriptionContext description() {
14030                        return getRuleContext(DescriptionContext.class,0);
14031                }
14032                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14033                public TerminalNode WS(int i) {
14034                        return getToken(JavadocParser.WS, i);
14035                }
14036                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14037                public TerminalNode NEWLINE(int i) {
14038                        return getToken(JavadocParser.NEWLINE, i);
14039                }
14040                public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); }
14041                public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); }
14042                public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); }
14043                public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); }
14044                public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); }
14045                public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); }
14046                public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); }
14047                public ReferenceContext reference() {
14048                        return getRuleContext(ReferenceContext.class,0);
14049                }
14050                public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); }
14051                public TerminalNode STRING(int i) {
14052                        return getToken(JavadocParser.STRING, i);
14053                }
14054                public List<HtmlElementContext> htmlElement() {
14055                        return getRuleContexts(HtmlElementContext.class);
14056                }
14057                public HtmlElementContext htmlElement(int i) {
14058                        return getRuleContext(HtmlElementContext.class,i);
14059                }
14060                public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); }
14061                public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); }
14062                public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); }
14063                public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); }
14064                public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); }
14065                public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); }
14066                public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); }
14067                public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); }
14068                public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); }
14069                public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); }
14070                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14071                public JavadocTagContext(ParserRuleContext parent, int invokingState) {
14072                        super(parent, invokingState);
14073                }
14074                @Override public int getRuleIndex() { return RULE_javadocTag; }
14075                @Override
14076                public void enterRule(ParseTreeListener listener) {
14077                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this);
14078                }
14079                @Override
14080                public void exitRule(ParseTreeListener listener) {
14081                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this);
14082                }
14083                @Override
14084                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14085                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this);
14086                        else return visitor.visitChildren(this);
14087                }
14088        }
14089
14090        public final JavadocTagContext javadocTag() throws RecognitionException {
14091                JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState());
14092                enterRule(_localctx, 142, RULE_javadocTag);
14093                int _la;
14094                try {
14095                        int _alt;
14096                        setState(1802);
14097                        switch (_input.LA(1)) {
14098                        case AUTHOR_LITERAL:
14099                                enterOuterAlt(_localctx, 1);
14100                                {
14101                                setState(1608);
14102                                match(AUTHOR_LITERAL);
14103                                setState(1612);
14104                                _errHandler.sync(this);
14105                                _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14106                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14107                                        if ( _alt==1 ) {
14108                                                {
14109                                                {
14110                                                setState(1609);
14111                                                _la = _input.LA(1);
14112                                                if ( !(_la==WS || _la==NEWLINE) ) {
14113                                                _errHandler.recoverInline(this);
14114                                                } else {
14115                                                        consume();
14116                                                }
14117                                                }
14118                                                } 
14119                                        }
14120                                        setState(1614);
14121                                        _errHandler.sync(this);
14122                                        _alt = getInterpreter().adaptivePredict(_input,135,_ctx);
14123                                }
14124                                setState(1616);
14125                                _errHandler.sync(this);
14126                                switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
14127                                case 1:
14128                                        {
14129                                        setState(1615);
14130                                        description();
14131                                        }
14132                                        break;
14133                                }
14134                                }
14135                                break;
14136                        case DEPRECATED_LITERAL:
14137                                enterOuterAlt(_localctx, 2);
14138                                {
14139                                setState(1618);
14140                                match(DEPRECATED_LITERAL);
14141                                setState(1622);
14142                                _errHandler.sync(this);
14143                                _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14144                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14145                                        if ( _alt==1 ) {
14146                                                {
14147                                                {
14148                                                setState(1619);
14149                                                _la = _input.LA(1);
14150                                                if ( !(_la==WS || _la==NEWLINE) ) {
14151                                                _errHandler.recoverInline(this);
14152                                                } else {
14153                                                        consume();
14154                                                }
14155                                                }
14156                                                } 
14157                                        }
14158                                        setState(1624);
14159                                        _errHandler.sync(this);
14160                                        _alt = getInterpreter().adaptivePredict(_input,137,_ctx);
14161                                }
14162                                setState(1626);
14163                                _errHandler.sync(this);
14164                                switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
14165                                case 1:
14166                                        {
14167                                        setState(1625);
14168                                        description();
14169                                        }
14170                                        break;
14171                                }
14172                                }
14173                                break;
14174                        case EXCEPTION_LITERAL:
14175                                enterOuterAlt(_localctx, 3);
14176                                {
14177                                setState(1628);
14178                                match(EXCEPTION_LITERAL);
14179                                setState(1632);
14180                                _errHandler.sync(this);
14181                                _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14182                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14183                                        if ( _alt==1 ) {
14184                                                {
14185                                                {
14186                                                setState(1629);
14187                                                _la = _input.LA(1);
14188                                                if ( !(_la==WS || _la==NEWLINE) ) {
14189                                                _errHandler.recoverInline(this);
14190                                                } else {
14191                                                        consume();
14192                                                }
14193                                                }
14194                                                } 
14195                                        }
14196                                        setState(1634);
14197                                        _errHandler.sync(this);
14198                                        _alt = getInterpreter().adaptivePredict(_input,139,_ctx);
14199                                }
14200                                setState(1636);
14201                                _errHandler.sync(this);
14202                                switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
14203                                case 1:
14204                                        {
14205                                        setState(1635);
14206                                        match(CLASS_NAME);
14207                                        }
14208                                        break;
14209                                }
14210                                setState(1641);
14211                                _errHandler.sync(this);
14212                                _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14213                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14214                                        if ( _alt==1 ) {
14215                                                {
14216                                                {
14217                                                setState(1638);
14218                                                _la = _input.LA(1);
14219                                                if ( !(_la==WS || _la==NEWLINE) ) {
14220                                                _errHandler.recoverInline(this);
14221                                                } else {
14222                                                        consume();
14223                                                }
14224                                                }
14225                                                } 
14226                                        }
14227                                        setState(1643);
14228                                        _errHandler.sync(this);
14229                                        _alt = getInterpreter().adaptivePredict(_input,141,_ctx);
14230                                }
14231                                setState(1645);
14232                                _errHandler.sync(this);
14233                                switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
14234                                case 1:
14235                                        {
14236                                        setState(1644);
14237                                        description();
14238                                        }
14239                                        break;
14240                                }
14241                                }
14242                                break;
14243                        case PARAM_LITERAL:
14244                                enterOuterAlt(_localctx, 4);
14245                                {
14246                                setState(1647);
14247                                match(PARAM_LITERAL);
14248                                setState(1651);
14249                                _errHandler.sync(this);
14250                                _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14251                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14252                                        if ( _alt==1 ) {
14253                                                {
14254                                                {
14255                                                setState(1648);
14256                                                _la = _input.LA(1);
14257                                                if ( !(_la==WS || _la==NEWLINE) ) {
14258                                                _errHandler.recoverInline(this);
14259                                                } else {
14260                                                        consume();
14261                                                }
14262                                                }
14263                                                } 
14264                                        }
14265                                        setState(1653);
14266                                        _errHandler.sync(this);
14267                                        _alt = getInterpreter().adaptivePredict(_input,143,_ctx);
14268                                }
14269                                setState(1655);
14270                                _errHandler.sync(this);
14271                                switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
14272                                case 1:
14273                                        {
14274                                        setState(1654);
14275                                        match(PARAMETER_NAME);
14276                                        }
14277                                        break;
14278                                }
14279                                setState(1660);
14280                                _errHandler.sync(this);
14281                                _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14282                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14283                                        if ( _alt==1 ) {
14284                                                {
14285                                                {
14286                                                setState(1657);
14287                                                _la = _input.LA(1);
14288                                                if ( !(_la==WS || _la==NEWLINE) ) {
14289                                                _errHandler.recoverInline(this);
14290                                                } else {
14291                                                        consume();
14292                                                }
14293                                                }
14294                                                } 
14295                                        }
14296                                        setState(1662);
14297                                        _errHandler.sync(this);
14298                                        _alt = getInterpreter().adaptivePredict(_input,145,_ctx);
14299                                }
14300                                setState(1664);
14301                                _errHandler.sync(this);
14302                                switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
14303                                case 1:
14304                                        {
14305                                        setState(1663);
14306                                        description();
14307                                        }
14308                                        break;
14309                                }
14310                                }
14311                                break;
14312                        case RETURN_LITERAL:
14313                                enterOuterAlt(_localctx, 5);
14314                                {
14315                                setState(1666);
14316                                match(RETURN_LITERAL);
14317                                setState(1670);
14318                                _errHandler.sync(this);
14319                                _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14320                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14321                                        if ( _alt==1 ) {
14322                                                {
14323                                                {
14324                                                setState(1667);
14325                                                _la = _input.LA(1);
14326                                                if ( !(_la==WS || _la==NEWLINE) ) {
14327                                                _errHandler.recoverInline(this);
14328                                                } else {
14329                                                        consume();
14330                                                }
14331                                                }
14332                                                } 
14333                                        }
14334                                        setState(1672);
14335                                        _errHandler.sync(this);
14336                                        _alt = getInterpreter().adaptivePredict(_input,147,_ctx);
14337                                }
14338                                setState(1674);
14339                                _errHandler.sync(this);
14340                                switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
14341                                case 1:
14342                                        {
14343                                        setState(1673);
14344                                        description();
14345                                        }
14346                                        break;
14347                                }
14348                                }
14349                                break;
14350                        case SEE_LITERAL:
14351                                enterOuterAlt(_localctx, 6);
14352                                {
14353                                setState(1676);
14354                                match(SEE_LITERAL);
14355                                setState(1680);
14356                                _errHandler.sync(this);
14357                                _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14358                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14359                                        if ( _alt==1 ) {
14360                                                {
14361                                                {
14362                                                setState(1677);
14363                                                _la = _input.LA(1);
14364                                                if ( !(_la==WS || _la==NEWLINE) ) {
14365                                                _errHandler.recoverInline(this);
14366                                                } else {
14367                                                        consume();
14368                                                }
14369                                                }
14370                                                } 
14371                                        }
14372                                        setState(1682);
14373                                        _errHandler.sync(this);
14374                                        _alt = getInterpreter().adaptivePredict(_input,149,_ctx);
14375                                }
14376                                setState(1684);
14377                                _errHandler.sync(this);
14378                                switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
14379                                case 1:
14380                                        {
14381                                        setState(1683);
14382                                        reference();
14383                                        }
14384                                        break;
14385                                }
14386                                setState(1690);
14387                                _errHandler.sync(this);
14388                                _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14389                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14390                                        if ( _alt==1 ) {
14391                                                {
14392                                                setState(1688);
14393                                                switch (_input.LA(1)) {
14394                                                case STRING:
14395                                                        {
14396                                                        setState(1686);
14397                                                        match(STRING);
14398                                                        }
14399                                                        break;
14400                                                case OPEN:
14401                                                        {
14402                                                        setState(1687);
14403                                                        htmlElement();
14404                                                        }
14405                                                        break;
14406                                                default:
14407                                                        throw new NoViableAltException(this);
14408                                                }
14409                                                } 
14410                                        }
14411                                        setState(1692);
14412                                        _errHandler.sync(this);
14413                                        _alt = getInterpreter().adaptivePredict(_input,152,_ctx);
14414                                }
14415                                setState(1696);
14416                                _errHandler.sync(this);
14417                                _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14418                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14419                                        if ( _alt==1 ) {
14420                                                {
14421                                                {
14422                                                setState(1693);
14423                                                _la = _input.LA(1);
14424                                                if ( !(_la==WS || _la==NEWLINE) ) {
14425                                                _errHandler.recoverInline(this);
14426                                                } else {
14427                                                        consume();
14428                                                }
14429                                                }
14430                                                } 
14431                                        }
14432                                        setState(1698);
14433                                        _errHandler.sync(this);
14434                                        _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
14435                                }
14436                                setState(1700);
14437                                _errHandler.sync(this);
14438                                switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
14439                                case 1:
14440                                        {
14441                                        setState(1699);
14442                                        description();
14443                                        }
14444                                        break;
14445                                }
14446                                }
14447                                break;
14448                        case SERIAL_LITERAL:
14449                                enterOuterAlt(_localctx, 7);
14450                                {
14451                                setState(1702);
14452                                match(SERIAL_LITERAL);
14453                                setState(1706);
14454                                _errHandler.sync(this);
14455                                _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14456                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14457                                        if ( _alt==1 ) {
14458                                                {
14459                                                {
14460                                                setState(1703);
14461                                                _la = _input.LA(1);
14462                                                if ( !(_la==WS || _la==NEWLINE) ) {
14463                                                _errHandler.recoverInline(this);
14464                                                } else {
14465                                                        consume();
14466                                                }
14467                                                }
14468                                                } 
14469                                        }
14470                                        setState(1708);
14471                                        _errHandler.sync(this);
14472                                        _alt = getInterpreter().adaptivePredict(_input,155,_ctx);
14473                                }
14474                                setState(1710);
14475                                _errHandler.sync(this);
14476                                switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
14477                                case 1:
14478                                        {
14479                                        setState(1709);
14480                                        _la = _input.LA(1);
14481                                        if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) {
14482                                        _errHandler.recoverInline(this);
14483                                        } else {
14484                                                consume();
14485                                        }
14486                                        }
14487                                        break;
14488                                }
14489                                setState(1713);
14490                                _errHandler.sync(this);
14491                                switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
14492                                case 1:
14493                                        {
14494                                        setState(1712);
14495                                        description();
14496                                        }
14497                                        break;
14498                                }
14499                                }
14500                                break;
14501                        case SERIAL_DATA_LITERAL:
14502                                enterOuterAlt(_localctx, 8);
14503                                {
14504                                setState(1715);
14505                                match(SERIAL_DATA_LITERAL);
14506                                setState(1719);
14507                                _errHandler.sync(this);
14508                                _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14509                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14510                                        if ( _alt==1 ) {
14511                                                {
14512                                                {
14513                                                setState(1716);
14514                                                _la = _input.LA(1);
14515                                                if ( !(_la==WS || _la==NEWLINE) ) {
14516                                                _errHandler.recoverInline(this);
14517                                                } else {
14518                                                        consume();
14519                                                }
14520                                                }
14521                                                } 
14522                                        }
14523                                        setState(1721);
14524                                        _errHandler.sync(this);
14525                                        _alt = getInterpreter().adaptivePredict(_input,158,_ctx);
14526                                }
14527                                setState(1723);
14528                                _errHandler.sync(this);
14529                                switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
14530                                case 1:
14531                                        {
14532                                        setState(1722);
14533                                        description();
14534                                        }
14535                                        break;
14536                                }
14537                                }
14538                                break;
14539                        case SERIAL_FIELD_LITERAL:
14540                                enterOuterAlt(_localctx, 9);
14541                                {
14542                                setState(1725);
14543                                match(SERIAL_FIELD_LITERAL);
14544                                setState(1729);
14545                                _errHandler.sync(this);
14546                                _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14547                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14548                                        if ( _alt==1 ) {
14549                                                {
14550                                                {
14551                                                setState(1726);
14552                                                _la = _input.LA(1);
14553                                                if ( !(_la==WS || _la==NEWLINE) ) {
14554                                                _errHandler.recoverInline(this);
14555                                                } else {
14556                                                        consume();
14557                                                }
14558                                                }
14559                                                } 
14560                                        }
14561                                        setState(1731);
14562                                        _errHandler.sync(this);
14563                                        _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
14564                                }
14565                                setState(1733);
14566                                _errHandler.sync(this);
14567                                switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
14568                                case 1:
14569                                        {
14570                                        setState(1732);
14571                                        match(FIELD_NAME);
14572                                        }
14573                                        break;
14574                                }
14575                                setState(1738);
14576                                _errHandler.sync(this);
14577                                _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14578                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14579                                        if ( _alt==1 ) {
14580                                                {
14581                                                {
14582                                                setState(1735);
14583                                                _la = _input.LA(1);
14584                                                if ( !(_la==WS || _la==NEWLINE) ) {
14585                                                _errHandler.recoverInline(this);
14586                                                } else {
14587                                                        consume();
14588                                                }
14589                                                }
14590                                                } 
14591                                        }
14592                                        setState(1740);
14593                                        _errHandler.sync(this);
14594                                        _alt = getInterpreter().adaptivePredict(_input,162,_ctx);
14595                                }
14596                                setState(1742);
14597                                _errHandler.sync(this);
14598                                switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
14599                                case 1:
14600                                        {
14601                                        setState(1741);
14602                                        match(FIELD_TYPE);
14603                                        }
14604                                        break;
14605                                }
14606                                setState(1747);
14607                                _errHandler.sync(this);
14608                                _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14609                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14610                                        if ( _alt==1 ) {
14611                                                {
14612                                                {
14613                                                setState(1744);
14614                                                _la = _input.LA(1);
14615                                                if ( !(_la==WS || _la==NEWLINE) ) {
14616                                                _errHandler.recoverInline(this);
14617                                                } else {
14618                                                        consume();
14619                                                }
14620                                                }
14621                                                } 
14622                                        }
14623                                        setState(1749);
14624                                        _errHandler.sync(this);
14625                                        _alt = getInterpreter().adaptivePredict(_input,164,_ctx);
14626                                }
14627                                setState(1751);
14628                                _errHandler.sync(this);
14629                                switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
14630                                case 1:
14631                                        {
14632                                        setState(1750);
14633                                        description();
14634                                        }
14635                                        break;
14636                                }
14637                                }
14638                                break;
14639                        case SINCE_LITERAL:
14640                                enterOuterAlt(_localctx, 10);
14641                                {
14642                                setState(1753);
14643                                match(SINCE_LITERAL);
14644                                setState(1757);
14645                                _errHandler.sync(this);
14646                                _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14647                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14648                                        if ( _alt==1 ) {
14649                                                {
14650                                                {
14651                                                setState(1754);
14652                                                _la = _input.LA(1);
14653                                                if ( !(_la==WS || _la==NEWLINE) ) {
14654                                                _errHandler.recoverInline(this);
14655                                                } else {
14656                                                        consume();
14657                                                }
14658                                                }
14659                                                } 
14660                                        }
14661                                        setState(1759);
14662                                        _errHandler.sync(this);
14663                                        _alt = getInterpreter().adaptivePredict(_input,166,_ctx);
14664                                }
14665                                setState(1761);
14666                                _errHandler.sync(this);
14667                                switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
14668                                case 1:
14669                                        {
14670                                        setState(1760);
14671                                        description();
14672                                        }
14673                                        break;
14674                                }
14675                                }
14676                                break;
14677                        case THROWS_LITERAL:
14678                                enterOuterAlt(_localctx, 11);
14679                                {
14680                                setState(1763);
14681                                match(THROWS_LITERAL);
14682                                setState(1767);
14683                                _errHandler.sync(this);
14684                                _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14685                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14686                                        if ( _alt==1 ) {
14687                                                {
14688                                                {
14689                                                setState(1764);
14690                                                _la = _input.LA(1);
14691                                                if ( !(_la==WS || _la==NEWLINE) ) {
14692                                                _errHandler.recoverInline(this);
14693                                                } else {
14694                                                        consume();
14695                                                }
14696                                                }
14697                                                } 
14698                                        }
14699                                        setState(1769);
14700                                        _errHandler.sync(this);
14701                                        _alt = getInterpreter().adaptivePredict(_input,168,_ctx);
14702                                }
14703                                setState(1771);
14704                                _errHandler.sync(this);
14705                                switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
14706                                case 1:
14707                                        {
14708                                        setState(1770);
14709                                        match(CLASS_NAME);
14710                                        }
14711                                        break;
14712                                }
14713                                setState(1776);
14714                                _errHandler.sync(this);
14715                                _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14716                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14717                                        if ( _alt==1 ) {
14718                                                {
14719                                                {
14720                                                setState(1773);
14721                                                _la = _input.LA(1);
14722                                                if ( !(_la==WS || _la==NEWLINE) ) {
14723                                                _errHandler.recoverInline(this);
14724                                                } else {
14725                                                        consume();
14726                                                }
14727                                                }
14728                                                } 
14729                                        }
14730                                        setState(1778);
14731                                        _errHandler.sync(this);
14732                                        _alt = getInterpreter().adaptivePredict(_input,170,_ctx);
14733                                }
14734                                setState(1780);
14735                                _errHandler.sync(this);
14736                                switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
14737                                case 1:
14738                                        {
14739                                        setState(1779);
14740                                        description();
14741                                        }
14742                                        break;
14743                                }
14744                                }
14745                                break;
14746                        case VERSION_LITERAL:
14747                                enterOuterAlt(_localctx, 12);
14748                                {
14749                                setState(1782);
14750                                match(VERSION_LITERAL);
14751                                setState(1786);
14752                                _errHandler.sync(this);
14753                                _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14754                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14755                                        if ( _alt==1 ) {
14756                                                {
14757                                                {
14758                                                setState(1783);
14759                                                _la = _input.LA(1);
14760                                                if ( !(_la==WS || _la==NEWLINE) ) {
14761                                                _errHandler.recoverInline(this);
14762                                                } else {
14763                                                        consume();
14764                                                }
14765                                                }
14766                                                } 
14767                                        }
14768                                        setState(1788);
14769                                        _errHandler.sync(this);
14770                                        _alt = getInterpreter().adaptivePredict(_input,172,_ctx);
14771                                }
14772                                setState(1790);
14773                                _errHandler.sync(this);
14774                                switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
14775                                case 1:
14776                                        {
14777                                        setState(1789);
14778                                        description();
14779                                        }
14780                                        break;
14781                                }
14782                                }
14783                                break;
14784                        case CUSTOM_NAME:
14785                                enterOuterAlt(_localctx, 13);
14786                                {
14787                                setState(1792);
14788                                match(CUSTOM_NAME);
14789                                setState(1796);
14790                                _errHandler.sync(this);
14791                                _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14792                                while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14793                                        if ( _alt==1 ) {
14794                                                {
14795                                                {
14796                                                setState(1793);
14797                                                _la = _input.LA(1);
14798                                                if ( !(_la==WS || _la==NEWLINE) ) {
14799                                                _errHandler.recoverInline(this);
14800                                                } else {
14801                                                        consume();
14802                                                }
14803                                                }
14804                                                } 
14805                                        }
14806                                        setState(1798);
14807                                        _errHandler.sync(this);
14808                                        _alt = getInterpreter().adaptivePredict(_input,174,_ctx);
14809                                }
14810                                setState(1800);
14811                                _errHandler.sync(this);
14812                                switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
14813                                case 1:
14814                                        {
14815                                        setState(1799);
14816                                        description();
14817                                        }
14818                                        break;
14819                                }
14820                                }
14821                                break;
14822                        default:
14823                                throw new NoViableAltException(this);
14824                        }
14825                }
14826                catch (RecognitionException re) {
14827                        _localctx.exception = re;
14828                        _errHandler.reportError(this, re);
14829                        _errHandler.recover(this, re);
14830                }
14831                finally {
14832                        exitRule();
14833                }
14834                return _localctx;
14835        }
14836
14837        public static class JavadocInlineTagContext extends ParserRuleContext {
14838                public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); }
14839                public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); }
14840                public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); }
14841                public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); }
14842                public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); }
14843                public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); }
14844                public ReferenceContext reference() {
14845                        return getRuleContext(ReferenceContext.class,0);
14846                }
14847                public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); }
14848                public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); }
14849                public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); }
14850                public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); }
14851                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
14852                public TerminalNode WS(int i) {
14853                        return getToken(JavadocParser.WS, i);
14854                }
14855                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
14856                public TerminalNode NEWLINE(int i) {
14857                        return getToken(JavadocParser.NEWLINE, i);
14858                }
14859                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
14860                public TerminalNode LEADING_ASTERISK(int i) {
14861                        return getToken(JavadocParser.LEADING_ASTERISK, i);
14862                }
14863                public List<TextContext> text() {
14864                        return getRuleContexts(TextContext.class);
14865                }
14866                public TextContext text(int i) {
14867                        return getRuleContext(TextContext.class,i);
14868                }
14869                public DescriptionContext description() {
14870                        return getRuleContext(DescriptionContext.class,0);
14871                }
14872                public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) {
14873                        super(parent, invokingState);
14874                }
14875                @Override public int getRuleIndex() { return RULE_javadocInlineTag; }
14876                @Override
14877                public void enterRule(ParseTreeListener listener) {
14878                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this);
14879                }
14880                @Override
14881                public void exitRule(ParseTreeListener listener) {
14882                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this);
14883                }
14884                @Override
14885                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
14886                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this);
14887                        else return visitor.visitChildren(this);
14888                }
14889        }
14890
14891        public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException {
14892                JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState());
14893                enterRule(_localctx, 144, RULE_javadocInlineTag);
14894                int _la;
14895                try {
14896                        int _alt;
14897                        enterOuterAlt(_localctx, 1);
14898                        {
14899                        setState(1804);
14900                        match(JAVADOC_INLINE_TAG_START);
14901                        setState(1880);
14902                        switch (_input.LA(1)) {
14903                        case CODE_LITERAL:
14904                                {
14905                                setState(1805);
14906                                match(CODE_LITERAL);
14907                                setState(1812);
14908                                _errHandler.sync(this);
14909                                _la = _input.LA(1);
14910                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
14911                                        {
14912                                        setState(1810);
14913                                        _errHandler.sync(this);
14914                                        switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
14915                                        case 1:
14916                                                {
14917                                                setState(1806);
14918                                                match(WS);
14919                                                }
14920                                                break;
14921                                        case 2:
14922                                                {
14923                                                setState(1807);
14924                                                match(NEWLINE);
14925                                                }
14926                                                break;
14927                                        case 3:
14928                                                {
14929                                                setState(1808);
14930                                                match(LEADING_ASTERISK);
14931                                                }
14932                                                break;
14933                                        case 4:
14934                                                {
14935                                                setState(1809);
14936                                                text();
14937                                                }
14938                                                break;
14939                                        }
14940                                        }
14941                                        setState(1814);
14942                                        _errHandler.sync(this);
14943                                        _la = _input.LA(1);
14944                                }
14945                                }
14946                                break;
14947                        case DOC_ROOT_LITERAL:
14948                                {
14949                                setState(1815);
14950                                match(DOC_ROOT_LITERAL);
14951                                setState(1819);
14952                                _errHandler.sync(this);
14953                                _la = _input.LA(1);
14954                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14955                                        {
14956                                        {
14957                                        setState(1816);
14958                                        _la = _input.LA(1);
14959                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14960                                        _errHandler.recoverInline(this);
14961                                        } else {
14962                                                consume();
14963                                        }
14964                                        }
14965                                        }
14966                                        setState(1821);
14967                                        _errHandler.sync(this);
14968                                        _la = _input.LA(1);
14969                                }
14970                                }
14971                                break;
14972                        case INHERIT_DOC_LITERAL:
14973                                {
14974                                setState(1822);
14975                                match(INHERIT_DOC_LITERAL);
14976                                setState(1826);
14977                                _errHandler.sync(this);
14978                                _la = _input.LA(1);
14979                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
14980                                        {
14981                                        {
14982                                        setState(1823);
14983                                        _la = _input.LA(1);
14984                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
14985                                        _errHandler.recoverInline(this);
14986                                        } else {
14987                                                consume();
14988                                        }
14989                                        }
14990                                        }
14991                                        setState(1828);
14992                                        _errHandler.sync(this);
14993                                        _la = _input.LA(1);
14994                                }
14995                                }
14996                                break;
14997                        case LINK_LITERAL:
14998                                {
14999                                setState(1829);
15000                                match(LINK_LITERAL);
15001                                setState(1833);
15002                                _errHandler.sync(this);
15003                                _la = _input.LA(1);
15004                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15005                                        {
15006                                        {
15007                                        setState(1830);
15008                                        _la = _input.LA(1);
15009                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15010                                        _errHandler.recoverInline(this);
15011                                        } else {
15012                                                consume();
15013                                        }
15014                                        }
15015                                        }
15016                                        setState(1835);
15017                                        _errHandler.sync(this);
15018                                        _la = _input.LA(1);
15019                                }
15020                                setState(1836);
15021                                reference();
15022                                setState(1838);
15023                                _errHandler.sync(this);
15024                                switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
15025                                case 1:
15026                                        {
15027                                        setState(1837);
15028                                        description();
15029                                        }
15030                                        break;
15031                                }
15032                                }
15033                                break;
15034                        case LINKPLAIN_LITERAL:
15035                                {
15036                                setState(1840);
15037                                match(LINKPLAIN_LITERAL);
15038                                setState(1844);
15039                                _errHandler.sync(this);
15040                                _la = _input.LA(1);
15041                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15042                                        {
15043                                        {
15044                                        setState(1841);
15045                                        _la = _input.LA(1);
15046                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15047                                        _errHandler.recoverInline(this);
15048                                        } else {
15049                                                consume();
15050                                        }
15051                                        }
15052                                        }
15053                                        setState(1846);
15054                                        _errHandler.sync(this);
15055                                        _la = _input.LA(1);
15056                                }
15057                                setState(1847);
15058                                reference();
15059                                setState(1849);
15060                                _errHandler.sync(this);
15061                                switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
15062                                case 1:
15063                                        {
15064                                        setState(1848);
15065                                        description();
15066                                        }
15067                                        break;
15068                                }
15069                                }
15070                                break;
15071                        case LITERAL_LITERAL:
15072                                {
15073                                setState(1851);
15074                                match(LITERAL_LITERAL);
15075                                setState(1858);
15076                                _errHandler.sync(this);
15077                                _la = _input.LA(1);
15078                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15079                                        {
15080                                        setState(1856);
15081                                        _errHandler.sync(this);
15082                                        switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
15083                                        case 1:
15084                                                {
15085                                                setState(1852);
15086                                                match(WS);
15087                                                }
15088                                                break;
15089                                        case 2:
15090                                                {
15091                                                setState(1853);
15092                                                match(NEWLINE);
15093                                                }
15094                                                break;
15095                                        case 3:
15096                                                {
15097                                                setState(1854);
15098                                                match(LEADING_ASTERISK);
15099                                                }
15100                                                break;
15101                                        case 4:
15102                                                {
15103                                                setState(1855);
15104                                                text();
15105                                                }
15106                                                break;
15107                                        }
15108                                        }
15109                                        setState(1860);
15110                                        _errHandler.sync(this);
15111                                        _la = _input.LA(1);
15112                                }
15113                                }
15114                                break;
15115                        case VALUE_LITERAL:
15116                                {
15117                                setState(1861);
15118                                match(VALUE_LITERAL);
15119                                setState(1865);
15120                                _errHandler.sync(this);
15121                                _la = _input.LA(1);
15122                                while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) {
15123                                        {
15124                                        {
15125                                        setState(1862);
15126                                        _la = _input.LA(1);
15127                                        if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15128                                        _errHandler.recoverInline(this);
15129                                        } else {
15130                                                consume();
15131                                        }
15132                                        }
15133                                        }
15134                                        setState(1867);
15135                                        _errHandler.sync(this);
15136                                        _la = _input.LA(1);
15137                                }
15138                                setState(1869);
15139                                _la = _input.LA(1);
15140                                if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) {
15141                                        {
15142                                        setState(1868);
15143                                        reference();
15144                                        }
15145                                }
15146
15147                                }
15148                                break;
15149                        case CUSTOM_NAME:
15150                                {
15151                                setState(1871);
15152                                match(CUSTOM_NAME);
15153                                setState(1873); 
15154                                _errHandler.sync(this);
15155                                _alt = 1;
15156                                do {
15157                                        switch (_alt) {
15158                                        case 1:
15159                                                {
15160                                                {
15161                                                setState(1872);
15162                                                _la = _input.LA(1);
15163                                                if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) {
15164                                                _errHandler.recoverInline(this);
15165                                                } else {
15166                                                        consume();
15167                                                }
15168                                                }
15169                                                }
15170                                                break;
15171                                        default:
15172                                                throw new NoViableAltException(this);
15173                                        }
15174                                        setState(1875); 
15175                                        _errHandler.sync(this);
15176                                        _alt = getInterpreter().adaptivePredict(_input,189,_ctx);
15177                                } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15178                                setState(1878);
15179                                _errHandler.sync(this);
15180                                switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
15181                                case 1:
15182                                        {
15183                                        setState(1877);
15184                                        description();
15185                                        }
15186                                        break;
15187                                }
15188                                }
15189                                break;
15190                        default:
15191                                throw new NoViableAltException(this);
15192                        }
15193                        setState(1882);
15194                        match(JAVADOC_INLINE_TAG_END);
15195                        }
15196                }
15197                catch (RecognitionException re) {
15198                        _localctx.exception = re;
15199                        _errHandler.reportError(this, re);
15200                        _errHandler.recover(this, re);
15201                }
15202                finally {
15203                        exitRule();
15204                }
15205                return _localctx;
15206        }
15207
15208        public static class HtmlCommentContext extends ParserRuleContext {
15209                public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); }
15210                public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); }
15211                public List<TextContext> text() {
15212                        return getRuleContexts(TextContext.class);
15213                }
15214                public TextContext text(int i) {
15215                        return getRuleContext(TextContext.class,i);
15216                }
15217                public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
15218                public TerminalNode NEWLINE(int i) {
15219                        return getToken(JavadocParser.NEWLINE, i);
15220                }
15221                public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); }
15222                public TerminalNode LEADING_ASTERISK(int i) {
15223                        return getToken(JavadocParser.LEADING_ASTERISK, i);
15224                }
15225                public HtmlCommentContext(ParserRuleContext parent, int invokingState) {
15226                        super(parent, invokingState);
15227                }
15228                @Override public int getRuleIndex() { return RULE_htmlComment; }
15229                @Override
15230                public void enterRule(ParseTreeListener listener) {
15231                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this);
15232                }
15233                @Override
15234                public void exitRule(ParseTreeListener listener) {
15235                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this);
15236                }
15237                @Override
15238                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15239                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this);
15240                        else return visitor.visitChildren(this);
15241                }
15242        }
15243
15244        public final HtmlCommentContext htmlComment() throws RecognitionException {
15245                HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState());
15246                enterRule(_localctx, 146, RULE_htmlComment);
15247                int _la;
15248                try {
15249                        enterOuterAlt(_localctx, 1);
15250                        {
15251                        setState(1884);
15252                        match(HTML_COMMENT_START);
15253                        setState(1890);
15254                        _errHandler.sync(this);
15255                        _la = _input.LA(1);
15256                        while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) {
15257                                {
15258                                setState(1888);
15259                                switch (_input.LA(1)) {
15260                                case WS:
15261                                case CHAR:
15262                                        {
15263                                        setState(1885);
15264                                        text();
15265                                        }
15266                                        break;
15267                                case NEWLINE:
15268                                        {
15269                                        setState(1886);
15270                                        match(NEWLINE);
15271                                        }
15272                                        break;
15273                                case LEADING_ASTERISK:
15274                                        {
15275                                        setState(1887);
15276                                        match(LEADING_ASTERISK);
15277                                        }
15278                                        break;
15279                                default:
15280                                        throw new NoViableAltException(this);
15281                                }
15282                                }
15283                                setState(1892);
15284                                _errHandler.sync(this);
15285                                _la = _input.LA(1);
15286                        }
15287                        setState(1893);
15288                        match(HTML_COMMENT_END);
15289                        }
15290                }
15291                catch (RecognitionException re) {
15292                        _localctx.exception = re;
15293                        _errHandler.reportError(this, re);
15294                        _errHandler.recover(this, re);
15295                }
15296                finally {
15297                        exitRule();
15298                }
15299                return _localctx;
15300        }
15301
15302        public static class TextContext extends ParserRuleContext {
15303                public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); }
15304                public TerminalNode CHAR(int i) {
15305                        return getToken(JavadocParser.CHAR, i);
15306                }
15307                public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); }
15308                public TerminalNode WS(int i) {
15309                        return getToken(JavadocParser.WS, i);
15310                }
15311                public TextContext(ParserRuleContext parent, int invokingState) {
15312                        super(parent, invokingState);
15313                }
15314                @Override public int getRuleIndex() { return RULE_text; }
15315                @Override
15316                public void enterRule(ParseTreeListener listener) {
15317                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this);
15318                }
15319                @Override
15320                public void exitRule(ParseTreeListener listener) {
15321                        if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this);
15322                }
15323                @Override
15324                public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
15325                        if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this);
15326                        else return visitor.visitChildren(this);
15327                }
15328        }
15329
15330        public final TextContext text() throws RecognitionException {
15331                TextContext _localctx = new TextContext(_ctx, getState());
15332                enterRule(_localctx, 148, RULE_text);
15333                int _la;
15334                try {
15335                        int _alt;
15336                        enterOuterAlt(_localctx, 1);
15337                        {
15338                        setState(1896); 
15339                        _errHandler.sync(this);
15340                        _alt = 1;
15341                        do {
15342                                switch (_alt) {
15343                                case 1:
15344                                        {
15345                                        {
15346                                        setState(1895);
15347                                        _la = _input.LA(1);
15348                                        if ( !(_la==WS || _la==CHAR) ) {
15349                                        _errHandler.recoverInline(this);
15350                                        } else {
15351                                                consume();
15352                                        }
15353                                        }
15354                                        }
15355                                        break;
15356                                default:
15357                                        throw new NoViableAltException(this);
15358                                }
15359                                setState(1898); 
15360                                _errHandler.sync(this);
15361                                _alt = getInterpreter().adaptivePredict(_input,194,_ctx);
15362                        } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
15363                        }
15364                }
15365                catch (RecognitionException re) {
15366                        _localctx.exception = re;
15367                        _errHandler.reportError(this, re);
15368                        _errHandler.recover(this, re);
15369                }
15370                finally {
15371                        exitRule();
15372                }
15373                return _localctx;
15374        }
15375
15376        public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
15377                switch (ruleIndex) {
15378                case 0:
15379                        return javadoc_sempred((JavadocContext)_localctx, predIndex);
15380                case 5:
15381                        return htmlTag_sempred((HtmlTagContext)_localctx, predIndex);
15382                case 8:
15383                        return paragraph_sempred((ParagraphContext)_localctx, predIndex);
15384                case 11:
15385                        return li_sempred((LiContext)_localctx, predIndex);
15386                case 14:
15387                        return tr_sempred((TrContext)_localctx, predIndex);
15388                case 17:
15389                        return td_sempred((TdContext)_localctx, predIndex);
15390                case 20:
15391                        return th_sempred((ThContext)_localctx, predIndex);
15392                case 23:
15393                        return body_sempred((BodyContext)_localctx, predIndex);
15394                case 26:
15395                        return colgroup_sempred((ColgroupContext)_localctx, predIndex);
15396                case 29:
15397                        return dd_sempred((DdContext)_localctx, predIndex);
15398                case 32:
15399                        return dt_sempred((DtContext)_localctx, predIndex);
15400                case 35:
15401                        return head_sempred((HeadContext)_localctx, predIndex);
15402                case 38:
15403                        return html_sempred((HtmlContext)_localctx, predIndex);
15404                case 41:
15405                        return option_sempred((OptionContext)_localctx, predIndex);
15406                case 44:
15407                        return tbody_sempred((TbodyContext)_localctx, predIndex);
15408                case 47:
15409                        return tfoot_sempred((TfootContext)_localctx, predIndex);
15410                case 50:
15411                        return thead_sempred((TheadContext)_localctx, predIndex);
15412                case 68:
15413                        return description_sempred((DescriptionContext)_localctx, predIndex);
15414                }
15415                return true;
15416        }
15417        private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) {
15418                switch (predIndex) {
15419                case 0:
15420                        return !isNextJavadocTag();
15421                }
15422                return true;
15423        }
15424        private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) {
15425                switch (predIndex) {
15426                case 1:
15427                        return !isNextJavadocTag();
15428                case 2:
15429                        return !isNextJavadocTag();
15430                }
15431                return true;
15432        }
15433        private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) {
15434                switch (predIndex) {
15435                case 3:
15436                        return !isNextJavadocTag();
15437                }
15438                return true;
15439        }
15440        private boolean li_sempred(LiContext _localctx, int predIndex) {
15441                switch (predIndex) {
15442                case 4:
15443                        return !isNextJavadocTag();
15444                }
15445                return true;
15446        }
15447        private boolean tr_sempred(TrContext _localctx, int predIndex) {
15448                switch (predIndex) {
15449                case 5:
15450                        return !isNextJavadocTag();
15451                }
15452                return true;
15453        }
15454        private boolean td_sempred(TdContext _localctx, int predIndex) {
15455                switch (predIndex) {
15456                case 6:
15457                        return !isNextJavadocTag();
15458                }
15459                return true;
15460        }
15461        private boolean th_sempred(ThContext _localctx, int predIndex) {
15462                switch (predIndex) {
15463                case 7:
15464                        return !isNextJavadocTag();
15465                }
15466                return true;
15467        }
15468        private boolean body_sempred(BodyContext _localctx, int predIndex) {
15469                switch (predIndex) {
15470                case 8:
15471                        return !isNextJavadocTag();
15472                }
15473                return true;
15474        }
15475        private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) {
15476                switch (predIndex) {
15477                case 9:
15478                        return !isNextJavadocTag();
15479                }
15480                return true;
15481        }
15482        private boolean dd_sempred(DdContext _localctx, int predIndex) {
15483                switch (predIndex) {
15484                case 10:
15485                        return !isNextJavadocTag();
15486                }
15487                return true;
15488        }
15489        private boolean dt_sempred(DtContext _localctx, int predIndex) {
15490                switch (predIndex) {
15491                case 11:
15492                        return !isNextJavadocTag();
15493                }
15494                return true;
15495        }
15496        private boolean head_sempred(HeadContext _localctx, int predIndex) {
15497                switch (predIndex) {
15498                case 12:
15499                        return !isNextJavadocTag();
15500                }
15501                return true;
15502        }
15503        private boolean html_sempred(HtmlContext _localctx, int predIndex) {
15504                switch (predIndex) {
15505                case 13:
15506                        return !isNextJavadocTag();
15507                }
15508                return true;
15509        }
15510        private boolean option_sempred(OptionContext _localctx, int predIndex) {
15511                switch (predIndex) {
15512                case 14:
15513                        return !isNextJavadocTag();
15514                }
15515                return true;
15516        }
15517        private boolean tbody_sempred(TbodyContext _localctx, int predIndex) {
15518                switch (predIndex) {
15519                case 15:
15520                        return !isNextJavadocTag();
15521                }
15522                return true;
15523        }
15524        private boolean tfoot_sempred(TfootContext _localctx, int predIndex) {
15525                switch (predIndex) {
15526                case 16:
15527                        return !isNextJavadocTag();
15528                }
15529                return true;
15530        }
15531        private boolean thead_sempred(TheadContext _localctx, int predIndex) {
15532                switch (predIndex) {
15533                case 17:
15534                        return !isNextJavadocTag();
15535                }
15536                return true;
15537        }
15538        private boolean description_sempred(DescriptionContext _localctx, int predIndex) {
15539                switch (predIndex) {
15540                case 18:
15541                        return !isNextJavadocTag();
15542                }
15543                return true;
15544        }
15545
15546        public static final String _serializedATN =
15547                "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u076f\4\2\t\2\4"+
15548                "\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"+
15549                "\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"+
15550                "\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"+
15551                "\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!"+
15552                "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
15553                ",\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"+
15554                "\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="+
15555                "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
15556                "\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"+
15557                "\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"+
15558                "\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"+
15559                "\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"+
15560                "\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"+
15561                "\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"+
15562                "\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"+
15563                "\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"+
15564                "\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"+
15565                "\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"+
15566                "\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"+
15567                "\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"+
15568                "\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"+
15569                "\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"+
15570                "\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"+
15571                "\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"+
15572                "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+
15573                "\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"+
15574                "\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"+
15575                "\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"+
15576                "\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"+
15577                "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+
15578                "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+
15579                "\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"+
15580                "\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"+
15581                "\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"+
15582                "\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"+
15583                "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+
15584                "\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"+
15585                "\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"+
15586                "\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"+
15587                "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+
15588                "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+
15589                "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+
15590                "\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"+
15591                "\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"+
15592                "\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"+
15593                "\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"+
15594                "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+
15595                "\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"+
15596                "\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"+
15597                "\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"+
15598                "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+
15599                "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+
15600                "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+
15601                "\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"+
15602                "\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"+
15603                "\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"+
15604                "\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"+
15605                "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+
15606                "\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"+
15607                "\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"+
15608                "\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"+
15609                "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+
15610                " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+
15611                "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
15612                "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
15613                "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+
15614                "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+
15615                "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\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%\3%\3%\3%\3%\3"+
15617                "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+
15618                "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+
15619                "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\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                "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+
15622                ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+
15623                "+\3+\3+\3+\3+\3+\3+\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+\7+\u046a\n+\f+\16+\u046d\13+"+
15625                "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+
15626                "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\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.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+
15629                "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+
15630                "\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"+
15631                "\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"+
15632                "\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"+
15633                "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+
15634                "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+
15635                "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+
15636                "\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"+
15637                "\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"+
15638                "\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"+
15639                "\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"+
15640                "\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"+
15641                "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+
15642                "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+
15643                "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+
15644                "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+
15645                "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+
15646                "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+
15647                "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+
15648                "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+
15649                "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+
15650                "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+
15651                "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+
15652                "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+
15653                "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+
15654                "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+
15655                "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+
15656                "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+
15657                "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+
15658                "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+
15659                "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+
15660                "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+
15661                "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+
15662                "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+
15663                "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+
15664                "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+
15665                "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+
15666                "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+
15667                "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+
15668                "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+
15669                "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+
15670                "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+
15671                "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+
15672                "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+
15673                "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+
15674                "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+
15675                "J\u0750\nJ\3J\3J\6J\u0754\nJ\rJ\16J\u0755\3J\5J\u0759\nJ\5J\u075b\nJ\3"+
15676                "J\3J\3K\3K\3K\3K\7K\u0763\nK\fK\16K\u0766\13K\3K\3K\3L\6L\u076b\nL\rL"+
15677                "\16L\u076c\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+
15678                "\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+
15679                "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6\6\b\b"+
15680                "\4\2=KYY\3\29:\3\2LX\4\2\37\37!!\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b\3\2\30"+
15681                "\31\4\2\6\6\32\32\u0a86\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7\3\2\2"+
15682                "\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2\2\2\20"+
15683                "\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2\2\30\u0191"+
15684                "\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2 \u0203\3\2"+
15685                "\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3\2\2\2*\u0260"+
15686                "\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62\u02d2\3\2\2"+
15687                "\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324\3\2\2\2<\u032f"+
15688                "\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D\u03a1\3\2\2\2F"+
15689                "\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2\2\2N\u03fe\3\2"+
15690                "\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470\3\2\2\2X\u047d"+
15691                "\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2`\u04cd\3\2\2\2"+
15692                "b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3\2\2\2j\u0550\3"+
15693                "\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584\3\2\2\2t\u0591"+
15694                "\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|\u05c5\3\2\2\2~"+
15695                "\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2\u0084\u05f9\3\2"+
15696                "\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616\3\2\2\2\u008c"+
15697                "\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092\u070e\3\2"+
15698                "\2\2\u0094\u075e\3\2\2\2\u0096\u076a\3\2\2\2\u0098\u00a1\5\4\3\2\u0099"+
15699                "\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c\u00a1"+
15700                "\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1\5\u0092"+
15701                "J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2\2\u00a0"+
15702                "\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2"+
15703                "\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
15704                "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+
15705                "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+
15706                "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+
15707                "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+
15708                "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+
15709                "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+
15710                "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+
15711                "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+
15712                "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+
15713                "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+
15714                "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+
15715                "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+
15716                "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+
15717                "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+
15718                "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+
15719                "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+
15720                "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+
15721                "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+
15722                "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+
15723                "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+
15724                "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+
15725                "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+
15726                "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+
15727                "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+
15728                "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+
15729                "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+
15730                "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+
15731                "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+
15732                "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+
15733                "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+
15734                "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+
15735                "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+
15736                "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+
15737                "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+
15738                "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+
15739                "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+
15740                "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+
15741                "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+
15742                "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+
15743                "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
15744                "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+
15745                "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+
15746                "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+
15747                "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+
15748                "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+
15749                "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+
15750                "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+
15751                "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+
15752                "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+
15753                "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+
15754                "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+
15755                "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+
15756                "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
15757                "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+
15758                "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+
15759                "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+
15760                "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+
15761                "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+
15762                "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+
15763                "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+
15764                "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+
15765                "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+
15766                "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+
15767                "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+
15768                "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
15769                "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+
15770                "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+
15771                "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+
15772                "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+
15773                "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+
15774                "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+
15775                "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+
15776                "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+
15777                "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+
15778                "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+
15779                "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+
15780                "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+
15781                "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+
15782                "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+
15783                "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+
15784                "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+
15785                "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+
15786                "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+
15787                "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+
15788                "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+
15789                "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+
15790                "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+
15791                "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+
15792                "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+
15793                "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+
15794                "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+
15795                "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+
15796                "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+
15797                "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+
15798                "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+
15799                "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
15800                "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+
15801                "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+
15802                "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+
15803                "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+
15804                "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+
15805                "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+
15806                "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+
15807                "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+
15808                "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+
15809                "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+
15810                "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+
15811                "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+
15812                "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+
15813                "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+
15814                "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+
15815                "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+
15816                "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+
15817                "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+
15818                "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+
15819                "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+
15820                "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+
15821                "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+
15822                "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+
15823                "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+
15824                "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+
15825                "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+
15826                "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+
15827                "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+
15828                "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+
15829                "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+
15830                "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+
15831                "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+
15832                "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+
15833                "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
15834                "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
15835                "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+
15836                "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+
15837                "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+
15838                "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+
15839                "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+
15840                "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+
15841                "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+
15842                "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+
15843                "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+
15844                "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+
15845                "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+
15846                "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+
15847                "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+
15848                "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+
15849                "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+
15850                "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+
15851                "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+
15852                "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+
15853                "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+
15854                "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+
15855                "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+
15856                "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+
15857                "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+
15858                "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+
15859                "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+
15860                "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+
15861                "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+
15862                "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+
15863                "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+
15864                "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+
15865                "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+
15866                "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+
15867                "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+
15868                "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+
15869                "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+
15870                "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+
15871                "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+
15872                "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+
15873                "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+
15874                "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+
15875                "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+
15876                "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+
15877                "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+
15878                "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+
15879                "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+
15880                "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+
15881                "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+
15882                "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+
15883                "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+
15884                "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+
15885                "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+
15886                "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+
15887                "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+
15888                "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+
15889                "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+
15890                "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+
15891                "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+
15892                "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+
15893                "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+
15894                "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+
15895                "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+
15896                "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+
15897                "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+
15898                "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+
15899                "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+
15900                "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+
15901                "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+
15902                "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+
15903                "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+
15904                "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+
15905                "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+
15906                "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+
15907                "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+
15908                "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+
15909                "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+
15910                "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+
15911                "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+
15912                "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+
15913                "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+
15914                "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+
15915                "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+
15916                "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+
15917                "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+
15918                "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
15919                "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+
15920                "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+
15921                "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+
15922                "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+
15923                "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+
15924                "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+
15925                "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+
15926                "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+
15927                "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+
15928                "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+
15929                "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+
15930                "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+
15931                "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+
15932                "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+
15933                "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+
15934                "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+
15935                "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+
15936                ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+
15937                "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+
15938                "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+
15939                "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+
15940                "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+
15941                "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+
15942                "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+
15943                "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+
15944                "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+
15945                "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+
15946                "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+
15947                "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+
15948                "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+
15949                "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+
15950                "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+
15951                "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+
15952                "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+
15953                "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+
15954                "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+
15955                "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+
15956                "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+
15957                "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+
15958                "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+
15959                "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+
15960                "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+
15961                "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+
15962                "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+
15963                "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+
15964                "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+
15965                "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+
15966                "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+
15967                "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+
15968                "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+
15969                "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+
15970                "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+
15971                "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+
15972                "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+
15973                "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+
15974                "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+
15975                "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+
15976                "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+
15977                "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+
15978                "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+
15979                "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+
15980                "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
15981                "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+
15982                "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+
15983                "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+
15984                "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+
15985                "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+
15986                "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+
15987                "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+
15988                "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+
15989                "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+
15990                ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+
15991                "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+
15992                "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+
15993                "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+
15994                "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+
15995                "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+
15996                "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+
15997                "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+
15998                "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+
15999                "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+
16000                "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+
16001                "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+
16002                "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+
16003                "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+
16004                "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+
16005                "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+
16006                "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+
16007                "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+
16008                "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+
16009                "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+
16010                "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+
16011                "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+
16012                "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+
16013                "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+
16014                "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+
16015                "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+
16016                "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
16017                "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+
16018                "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+
16019                "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+
16020                "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+
16021                "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+
16022                "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+
16023                "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+
16024                "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+
16025                "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+
16026                "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+
16027                "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+
16028                "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+
16029                "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+
16030                "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+
16031                "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+
16032                "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+
16033                "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+
16034                "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+
16035                "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+
16036                "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+
16037                "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+
16038                "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+
16039                "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+
16040                "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+
16041                "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+
16042                "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+
16043                "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+
16044                "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+
16045                "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+
16046                "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+
16047                "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+
16048                "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+
16049                "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+
16050                "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+
16051                "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+
16052                "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+
16053                "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+
16054                "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+
16055                "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+
16056                "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+
16057                "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+
16058                "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+
16059                "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+
16060                "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+
16061                "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+
16062                "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+
16063                "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+
16064                "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+
16065                "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+
16066                "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+
16067                "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+
16068                "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+
16069                "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+
16070                "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+
16071                "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+
16072                "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+
16073                "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+
16074                "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+
16075                "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+
16076                "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+
16077                "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
16078                "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+
16079                "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+
16080                "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+
16081                "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+
16082                "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+
16083                "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+
16084                "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+
16085                "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+
16086                "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+
16087                "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+
16088                "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+
16089                "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+
16090                "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+
16091                "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+
16092                "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+
16093                "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+
16094                "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+
16095                "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+
16096                "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+
16097                "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+
16098                "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+
16099                "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+
16100                "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+
16101                "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+
16102                "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+
16103                "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+
16104                "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+
16105                "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+
16106                "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+
16107                "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+
16108                "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+
16109                "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+
16110                "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+
16111                "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+
16112                "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+
16113                "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+
16114                "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+
16115                "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+
16116                "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+
16117                "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+
16118                "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+
16119                "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+
16120                "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+
16121                "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+
16122                "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+
16123                "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+
16124                "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+
16125                "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+
16126                "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+
16127                "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+
16128                "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+
16129                "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+
16130                "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+
16131                "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+
16132                "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+
16133                "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+
16134                "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+
16135                "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+
16136                "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+
16137                "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+
16138                "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+
16139                "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+
16140                "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+
16141                "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+
16142                "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+
16143                "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+
16144                "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+
16145                "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+
16146                "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+
16147                "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+
16148                "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+
16149                "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+
16150                "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+
16151                "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+
16152                "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+
16153                "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+
16154                "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+
16155                "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+
16156                "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+
16157                "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+
16158                "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+
16159                "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+
16160                "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+
16161                "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+
16162                "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+
16163                "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+
16164                "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+
16165                "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+
16166                "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+
16167                "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+
16168                "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+
16169                "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+
16170                "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+
16171                "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+
16172                "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+
16173                "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+
16174                "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+
16175                "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+
16176                "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+
16177                "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+
16178                "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+
16179                "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+
16180                "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+
16181                "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+
16182                "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+
16183                "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+
16184                "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+
16185                "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+
16186                "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+
16187                "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+
16188                "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+
16189                "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+
16190                "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+
16191                "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+
16192                "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+
16193                "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+
16194                "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+
16195                "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+
16196                "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+
16197                "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+
16198                "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+
16199                "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+
16200                "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+
16201                "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+
16202                "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+
16203                "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+
16204                "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+
16205                "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+
16206                "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+
16207                "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+
16208                "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+
16209                "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+
16210                "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+
16211                "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+
16212                "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+
16213                "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+
16214                "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+
16215                "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+
16216                "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+
16217                "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+
16218                "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+
16219                "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+
16220                "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+
16221                "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+
16222                "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+
16223                "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+
16224                "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+
16225                "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+
16226                "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+
16227                "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+
16228                "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+
16229                "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+
16230                "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+
16231                "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+
16232                "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+
16233                "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+
16234                "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+
16235                "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+
16236                "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+
16237                "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+
16238                "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+
16239                "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+
16240                "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+
16241                "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+
16242                "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+
16243                "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+
16244                "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+
16245                "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+
16246                "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+
16247                "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+
16248                "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+
16249                "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+
16250                "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+
16251                "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+
16252                "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+
16253                "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+
16254                "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+
16255                "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+
16256                "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+
16257                "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+
16258                "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+
16259                "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+
16260                "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+
16261                "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+
16262                "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+
16263                "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+
16264                "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+
16265                "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+
16266                "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+
16267                "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+
16268                "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+
16269                "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+
16270                "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+
16271                "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+
16272                "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+
16273                "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+
16274                "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+
16275                "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+
16276                "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+
16277                "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+
16278                "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+
16279                "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+
16280                "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+
16281                "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+
16282                "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+
16283                "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+
16284                "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+
16285                "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+
16286                "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+
16287                "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+
16288                "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+
16289                "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+
16290                "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+
16291                "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+
16292                "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+
16293                "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+
16294                "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+
16295                "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+
16296                "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+
16297                "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+
16298                "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+
16299                "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+
16300                "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+
16301                "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+
16302                "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+
16303                "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+
16304                "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+
16305                "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+
16306                "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+
16307                "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+
16308                "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+
16309                "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+
16310                "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+
16311                "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+
16312                "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+
16313                "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+
16314                "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+
16315                "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+
16316                "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+
16317                "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+
16318                "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+
16319                "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+
16320                "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+
16321                "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+
16322                "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+
16323                "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+
16324                "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+
16325                "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+
16326                "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+
16327                "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+
16328                "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+
16329                "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+
16330                "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+
16331                "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+
16332                "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+
16333                "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+
16334                "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+
16335                "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+
16336                "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+
16337                "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+
16338                "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+
16339                "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+
16340                "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+
16341                "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+
16342                "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+
16343                "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+
16344                "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+
16345                "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+
16346                "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+
16347                "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+
16348                "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+
16349                "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+
16350                "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+
16351                "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+
16352                "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+
16353                "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+
16354                "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+
16355                "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+
16356                "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+
16357                "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+
16358                "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+
16359                "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+
16360                "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+
16361                "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+
16362                "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+
16363                "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+
16364                "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+
16365                "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+
16366                "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+
16367                "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+
16368                "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+
16369                "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+
16370                "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+
16371                "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+
16372                "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+
16373                "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+
16374                "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+
16375                "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+
16376                "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+
16377                "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+
16378                "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+
16379                "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+
16380                "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+
16381                "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+
16382                "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+
16383                "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+
16384                "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+
16385                "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+
16386                "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+
16387                "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+
16388                "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+
16389                "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+
16390                "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+
16391                "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+
16392                "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+
16393                "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+
16394                "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+
16395                "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+
16396                "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+
16397                "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+
16398                "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+
16399                "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+
16400                "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+
16401                "\u0091\3\2\2\2\u070e\u075a\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+
16402                "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+
16403                "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+
16404                "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+
16405                "\u075b\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+
16406                "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+
16407                "\u071e\3\2\2\2\u071e\u075b\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+
16408                "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+
16409                "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075b\3\2\2\2\u0726\u0724\3\2"+
16410                "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+
16411                "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+
16412                "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+
16413                "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075b\3\2\2\2\u0732\u0736"+
16414                "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+
16415                "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+
16416                "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+
16417                "\2\2\u073b\u073c\3\2\2\2\u073c\u075b\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+
16418                "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+
16419                "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+
16420                "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+
16421                "\2\2\u0745\u075b\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+
16422                "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+
16423                "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
16424                "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075b"+
16425                "\3\2\2\2\u0751\u0753\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+
16426                "\u0754\u0755\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0758"+
16427                "\3\2\2\2\u0757\u0759\5\u008aF\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2"+
16428                "\2\u0759\u075b\3\2\2\2\u075a\u070f\3\2\2\2\u075a\u0719\3\2\2\2\u075a\u0720"+
16429                "\3\2\2\2\u075a\u0727\3\2\2\2\u075a\u0732\3\2\2\2\u075a\u073d\3\2\2\2\u075a"+
16430                "\u0747\3\2\2\2\u075a\u0751\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u075d\7\26"+
16431                "\2\2\u075d\u0093\3\2\2\2\u075e\u0764\7\4\2\2\u075f\u0763\5\u0096L\2\u0760"+
16432                "\u0763\7\b\2\2\u0761\u0763\7\3\2\2\u0762\u075f\3\2\2\2\u0762\u0760\3\2"+
16433                "\2\2\u0762\u0761\3\2\2\2\u0763\u0766\3\2\2\2\u0764\u0762\3\2\2\2\u0764"+
16434                "\u0765\3\2\2\2\u0765\u0767\3\2\2\2\u0766\u0764\3\2\2\2\u0767\u0768\7]"+
16435                "\2\2\u0768\u0095\3\2\2\2\u0769\u076b\t\n\2\2\u076a\u0769\3\2\2\2\u076b"+
16436                "\u076c\3\2\2\2\u076c\u076a\3\2\2\2\u076c\u076d\3\2\2\2\u076d\u0097\3\2"+
16437                "\2\2\u00c5\u00a0\u00a2\u00a6\u00ab\u00b1\u00e5\u00ed\u00ef\u00fa\u0103"+
16438                "\u010a\u0110\u011b\u011d\u012b\u012d\u0132\u013a\u013c\u0147\u0172\u0174"+
16439                "\u017f\u0181\u018c\u01b7\u01b9\u01c4\u01c6\u01d1\u01fc\u01fe\u0209\u020b"+
16440                "\u0216\u0241\u0243\u024e\u0250\u025b\u0286\u0288\u0293\u0295\u02a0\u02cb"+
16441                "\u02cd\u02d8\u02da\u02e5\u0310\u0312\u031d\u031f\u032a\u0355\u0357\u0362"+
16442                "\u0364\u036f\u039a\u039c\u03a7\u03a9\u03b4\u03df\u03e1\u03ec\u03ee\u03f9"+
16443                "\u0424\u0426\u0431\u0433\u043e\u0469\u046b\u0476\u0478\u0483\u04ae\u04b0"+
16444                "\u04bb\u04bd\u04c8\u04f3\u04f5\u0500\u0502\u050d\u0538\u053a\u054e\u0556"+
16445                "\u0558\u0563\u0565\u0570\u0572\u057d\u057f\u058a\u058c\u0597\u0599\u05a4"+
16446                "\u05a6\u05b1\u05b3\u05be\u05c0\u05cb\u05cd\u05d8\u05da\u05e5\u05e7\u05f2"+
16447                "\u05f4\u05ff\u0601\u0616\u0618\u061e\u0622\u0625\u0628\u062d\u0630\u0633"+
16448                "\u0636\u0639\u063d\u063f\u0645\u064e\u0652\u0658\u065c\u0662\u0666\u066b"+
16449                "\u066f\u0675\u0679\u067e\u0682\u0688\u068c\u0692\u0696\u069a\u069c\u06a2"+
16450                "\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9"+
16451                "\u06df\u06e3\u06e9\u06ed\u06f2\u06f6\u06fc\u0700\u0706\u070a\u070c\u0714"+
16452                "\u0716\u071d\u0724\u072b\u0730\u0736\u073b\u0742\u0744\u074b\u074f\u0755"+
16453                "\u0758\u075a\u0762\u0764\u076c";
16454        public static final ATN _ATN =
16455                new ATNDeserializer().deserialize(_serializedATN.toCharArray());
16456        static {
16457                _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
16458                for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
16459                        _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
16460                }
16461        }
16462}